feat(cli): expand remote player, opaque play id, tray without libindicator

Add CLI commands for stop, shuffle, repeat, mute, star, rating, reload,
server list/switch, and Subsonic search; publish extra snapshot fields and
server/search JSON for tooling. Single `play <id>` resolves track, album,
or artist; artists play a shuffled full discography.

Guard Linux tray creation with catch_unwind when Ayatana/AppIndicator .so
is missing. Harden bash completion against zsh sourcing (compopt). Narrow
AudioEngine field visibility to silence private_interfaces warnings.

src-tauri/src/audio.rs

@@ -1473,7 +1473,7 @@ pub struct AudioEngine {
     pub eq_gains: Arc<[AtomicU32; 10]>,
     pub eq_enabled: Arc<AtomicBool>,
     pub eq_pre_gain: Arc<AtomicU32>,
-    pub preloaded: Arc<Mutex<Option<PreloadedTrack>>>,
+    pub(crate) preloaded: Arc<Mutex<Option<PreloadedTrack>>>,
     pub crossfade_enabled: Arc<AtomicBool>,
     pub crossfade_secs: Arc<AtomicU32>,
     pub fading_out_sink: Arc<Mutex<Option<Sink>>>,
@@ -1482,7 +1482,7 @@ pub struct AudioEngine {
     pub gapless_enabled: Arc<AtomicBool>,
     /// Info about the next-up chained track (gapless mode).
     /// The progress task reads this when `current_source_done` fires.
-    pub chained_info: Arc<Mutex<Option<ChainedInfo>>>,
+    pub(crate) chained_info: Arc<Mutex<Option<ChainedInfo>>>,
     /// Atomic sample counter — incremented by CountingSource in the audio thread.
     /// Progress task reads this for drift-free position tracking.
     pub samples_played: Arc<AtomicU64>,
@@ -1495,7 +1495,7 @@ pub struct AudioEngine {
     pub gapless_switch_at: Arc<AtomicU64>,
     /// Active radio session state.  None for regular (non-radio) tracks.
     /// Dropping the value aborts the HTTP download task via RadioLiveState::Drop.
-    pub radio_state: Mutex<Option<RadioLiveState>>,
+    pub(crate) radio_state: Mutex<Option<RadioLiveState>>,
 }
 
 pub struct AudioCurrent {

src-tauri/src/cli.rs

@@ -12,13 +12,37 @@ use serde_json::Value;
 use tauri::{AppHandle, Emitter, Runtime};
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum RepeatCliMode {
+    Off,
+    All,
+    One,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum SearchCliScope {
+    Track,
+    Album,
+    Artist,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub enum PlayerCliCmd {
     Next,
     Prev,
     Play,
+    PlayOpaqueId(String),
     Pause,
+    Stop,
     Seek { delta_secs: i32 },
     Volume { percent: u8 },
+    ShuffleQueue,
+    Repeat(RepeatCliMode),
+    Mute,
+    Unmute,
+    StarCurrent,
+    UnstarCurrent,
+    Rating { stars: u8 },
+    ReloadPlayer,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -37,6 +61,12 @@ pub enum CliCommand {
     /// `"all"` or a music-folder id from `library list`.
     LibrarySet(String),
     Mix(MixCliMode),
+    ServerList,
+    ServerSet(String),
+    Search {
+        scope: SearchCliScope,
+        query: String,
+    },
 }
 
 pub fn wants_version(args: &[String]) -> bool {
@@ -63,7 +93,7 @@ pub fn wants_quiet(args: &[String]) -> bool {
         .any(|a| a == "--quiet" || a == "-q")
 }
 
-/// Machine-readable output for `--json` with `audio-device list` or `library list`.
+/// Machine-readable output for `--json` with list/search commands (`audio-device`, `library`, `server`, `search`).
 pub fn wants_cli_json_output(args: &[String]) -> bool {
     args.iter().skip(1).any(|a| a == "--json")
 }
@@ -100,6 +130,24 @@ pub fn cli_library_response_path() -> PathBuf {
     std::env::temp_dir().join("psysonic-cli-library.json")
 }
 
+pub fn cli_server_list_path() -> PathBuf {
+    if let Ok(dir) = std::env::var("XDG_RUNTIME_DIR") {
+        if !dir.is_empty() {
+            return PathBuf::from(dir).join("psysonic-cli-servers.json");
+        }
+    }
+    std::env::temp_dir().join("psysonic-cli-servers.json")
+}
+
+pub fn cli_search_response_path() -> PathBuf {
+    if let Ok(dir) = std::env::var("XDG_RUNTIME_DIR") {
+        if !dir.is_empty() {
+            return PathBuf::from(dir).join("psysonic-cli-search.json");
+        }
+    }
+    std::env::temp_dir().join("psysonic-cli-search.json")
+}
+
 /// `psysonic completions …` — returns exit code when this argv should not start the GUI.
 pub fn try_completions_dispatch(args: &[String]) -> Option<i32> {
     if args.get(1).map(|s| s.as_str()) != Some("completions") {
@@ -186,18 +234,32 @@ pub fn print_help(program: &str) {
     eprintln!("  Windows / macOS: handled via single-instance (a helper process may run briefly).\n");
     eprintln!("  Global flags (place before --player when needed):");
     eprintln!("    --quiet | -q     Suppress \"OK: …\" lines (stderr errors are always shown).");
-    eprintln!("    --json           With `audio-device list` or `library list`: JSON on stdout.");
+    eprintln!("    --json           With `audio-device list`, `library list`, `server list`, or `search`: JSON on stdout.");
     eprintln!("    Use  {program} -q --player seek -5  so the seek delta is not parsed as a flag.\n");
     eprintln!("  Playback");
-    eprintln!("    {program} [--quiet|-q] --player next | prev | play | pause");
+    eprintln!("    {program} [--quiet|-q] --player next | prev | play | pause | stop");
+    eprintln!("    {program} [--quiet|-q] --player play <id>   Track, album, or artist id (artist → shuffled library).");
     eprintln!("    {program} [--quiet|-q] --player seek <seconds>      Integer delta, e.g. 15 or -10");
-    eprintln!("    {program} [--quiet|-q] --player volume <0-100>     Absolute volume percent.\n");
+    eprintln!("    {program} [--quiet|-q] --player volume <0-100>     Absolute volume percent.");
+    eprintln!("    {program} [--quiet|-q] --player shuffle         Shuffle the current queue.");
+    eprintln!("    {program} [--quiet|-q] --player repeat off|all|one");
+    eprintln!("    {program} [--quiet|-q] --player mute | unmute");
+    eprintln!("    {program} [--quiet|-q] --player star | unstar     Current track (Subsonic star).");
+    eprintln!("    {program} [--quiet|-q] --player rating <0-5>     Set song rating (0 clears).");
+    eprintln!("    {program} [--quiet|-q] --player reload          Restart audio for the current track or reload server queue.\n");
     eprintln!("  Audio output");
     eprintln!("    {program} [--json] --player audio-device list");
     eprintln!("    {program} --player audio-device set <device-id|default>\n");
     eprintln!("  Music library (Subsonic music folders for the active server)");
     eprintln!("    {program} [--json] --player library list");
     eprintln!("    {program} --player library set all | <folder-id>\n");
+    eprintln!("  Servers (saved profiles — same as the in-app server switcher)");
+    eprintln!("    {program} [--json] --player server list");
+    eprintln!("    {program} --player server set <server-id>\n");
+    eprintln!("  Search (active server; respects library folder filter)");
+    eprintln!("    {program} [--json] --player search track <query…>");
+    eprintln!("    {program} [--json] --player search album <query…>");
+    eprintln!("    {program} [--json] --player search artist <query…>\n");
     eprintln!("  Instant mix (from the track that is currently loaded)");
     eprintln!("    {program} --player mix append");
     eprintln!("    {program} --player mix new\n");
@@ -275,6 +337,186 @@ pub fn write_library_cli_response(payload: &Value) -> Result<(), String> {
     Ok(())
 }
 
+pub fn write_server_list_cli_response(payload: &Value) -> Result<(), String> {
+    let path = cli_server_list_path();
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
+    }
+    let data = serde_json::to_string_pretty(payload).map_err(|e| e.to_string())?;
+    let tmp = path.with_extension("json.tmp");
+    std::fs::write(&tmp, &data).map_err(|e| e.to_string())?;
+    std::fs::rename(&tmp, &path).map_err(|e| e.to_string())?;
+    Ok(())
+}
+
+pub fn write_search_cli_response(payload: &Value) -> Result<(), String> {
+    let path = cli_search_response_path();
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
+    }
+    let data = serde_json::to_string_pretty(payload).map_err(|e| e.to_string())?;
+    let tmp = path.with_extension("json.tmp");
+    std::fs::write(&tmp, &data).map_err(|e| e.to_string())?;
+    std::fs::rename(&tmp, &path).map_err(|e| e.to_string())?;
+    Ok(())
+}
+
+/// Wait for `psysonic-cli-servers.json` after `cli:server-list`.
+fn read_server_list_cli_response_blocking(max_wait: Duration) -> String {
+    let path = cli_server_list_path();
+    let deadline = Instant::now() + max_wait;
+    loop {
+        if let Ok(text) = std::fs::read_to_string(&path) {
+            let trimmed = text.trim();
+            if let Ok(v) = serde_json::from_str::<Value>(trimmed) {
+                if v.get("servers").and_then(|x| x.as_array()).is_some() {
+                    return text;
+                }
+            }
+        }
+        if Instant::now() >= deadline {
+            break;
+        }
+        std::thread::sleep(Duration::from_millis(40));
+    }
+    std::fs::read_to_string(&path).unwrap_or_else(|_| "{}".into())
+}
+
+pub fn print_server_list_cli_stdout(text: &str, json_out: bool) {
+    if json_out {
+        println!("{}", text.trim());
+        return;
+    }
+    if let Ok(v) = serde_json::from_str::<Value>(text) {
+        print_server_list_human(&v);
+    } else {
+        println!("{}", text.trim());
+    }
+}
+
+fn print_server_list_human(v: &Value) {
+    if let Some(sid) = v.get("active_server_id").and_then(|x| x.as_str()) {
+        println!("active_server_id: {sid}");
+    } else {
+        println!("active_server_id: (none)");
+    }
+    println!("servers:");
+    if let Some(Value::Array(rows)) = v.get("servers") {
+        if rows.is_empty() {
+            println!("  (none)");
+            return;
+        }
+        for row in rows {
+            let id = row.get("id").and_then(|x| x.as_str()).unwrap_or("?");
+            let name = row.get("name").and_then(|x| x.as_str()).unwrap_or("?");
+            println!("  - {id}\t{name}");
+        }
+    } else {
+        println!("  (invalid JSON: missing servers array)");
+    }
+}
+
+/// Wait for `psysonic-cli-search.json` after `cli:search`.
+fn read_search_cli_response_blocking(max_wait: Duration) -> String {
+    let path = cli_search_response_path();
+    let deadline = Instant::now() + max_wait;
+    loop {
+        if let Ok(text) = std::fs::read_to_string(&path) {
+            let trimmed = text.trim();
+            if let Ok(v) = serde_json::from_str::<Value>(trimmed) {
+                let ready = v.get("ready").and_then(|x| x.as_bool()) == Some(true);
+                let has_err = v.get("error").and_then(|x| x.as_str()).is_some_and(|s| !s.is_empty());
+                if ready || has_err {
+                    return text;
+                }
+            }
+        }
+        if Instant::now() >= deadline {
+            break;
+        }
+        std::thread::sleep(Duration::from_millis(40));
+    }
+    std::fs::read_to_string(&path).unwrap_or_else(|_| "{}".into())
+}
+
+pub fn print_search_cli_stdout(text: &str, json_out: bool) {
+    if json_out {
+        println!("{}", text.trim());
+        return;
+    }
+    if let Ok(v) = serde_json::from_str::<Value>(text) {
+        print_search_human(&v);
+    } else {
+        println!("{}", text.trim());
+    }
+}
+
+fn print_search_human(v: &Value) {
+    if let Some(err) = v.get("error").and_then(|x| x.as_str()) {
+        if !err.is_empty() {
+            println!("error: {err}");
+            return;
+        }
+    }
+    let scope = v.get("scope").and_then(|x| x.as_str()).unwrap_or("?");
+    let query = v.get("query").and_then(|x| x.as_str()).unwrap_or("");
+    println!("scope: {scope}");
+    println!("query: {query}");
+    match scope {
+        "track" => {
+            println!("songs:");
+            if let Some(Value::Array(rows)) = v.get("songs") {
+                if rows.is_empty() {
+                    println!("  (none)");
+                    return;
+                }
+                for row in rows {
+                    let id = row.get("id").and_then(|x| x.as_str()).unwrap_or("?");
+                    let title = row.get("title").and_then(|x| x.as_str()).unwrap_or("?");
+                    let artist = row.get("artist").and_then(|x| x.as_str()).unwrap_or("?");
+                    println!("  - {id}\t{artist} — {title}");
+                }
+            } else {
+                println!("  (missing songs array)");
+            }
+        }
+        "album" => {
+            println!("albums:");
+            if let Some(Value::Array(rows)) = v.get("albums") {
+                if rows.is_empty() {
+                    println!("  (none)");
+                    return;
+                }
+                for row in rows {
+                    let id = row.get("id").and_then(|x| x.as_str()).unwrap_or("?");
+                    let name = row.get("name").and_then(|x| x.as_str()).unwrap_or("?");
+                    let artist = row.get("artist").and_then(|x| x.as_str()).unwrap_or("?");
+                    println!("  - {id}\t{artist} — {name}");
+                }
+            } else {
+                println!("  (missing albums array)");
+            }
+        }
+        "artist" => {
+            println!("artists:");
+            if let Some(Value::Array(rows)) = v.get("artists") {
+                if rows.is_empty() {
+                    println!("  (none)");
+                    return;
+                }
+                for row in rows {
+                    let id = row.get("id").and_then(|x| x.as_str()).unwrap_or("?");
+                    let name = row.get("name").and_then(|x| x.as_str()).unwrap_or("?");
+                    println!("  - {id}\t{name}");
+                }
+            } else {
+                println!("  (missing artists array)");
+            }
+        }
+        _ => println!("(unknown scope)"),
+    }
+}
+
 fn tauri_identifier() -> &'static str {
     static ID: OnceLock<String> = OnceLock::new();
     ID.get_or_init(|| {
@@ -439,12 +681,28 @@ fn print_info_human(v: &Value) {
         "volume",
         "queue_index",
         "queue_length",
+        "repeat_mode",
+        "current_track_user_rating",
+        "current_track_starred",
     ] {
         if let Some(val) = o.get(key) {
             println!("  {key}: {}", value_inline(val));
         }
     }
 
+    println!("=== servers (saved) ===");
+    match o.get("servers").and_then(|x| x.as_array()) {
+        None => println!("(none)"),
+        Some(rows) if rows.is_empty() => println!("(none)"),
+        Some(rows) => {
+            for row in rows {
+                let id = row.get("id").and_then(|x| x.as_str()).unwrap_or("?");
+                let name = row.get("name").and_then(|x| x.as_str()).unwrap_or("?");
+                println!("  - {id}\t{name}");
+            }
+        }
+    }
+
     println!("=== queue ({} items) ===", o.get("queue_length").and_then(|x| x.as_u64()).unwrap_or(0));
     if let Some(Value::Array(items)) = o.get("queue") {
         for (i, item) in items.iter().enumerate() {
@@ -481,13 +739,50 @@ fn value_inline(v: &Value) -> String {
     }
 }
 
+fn parse_repeat_mode(arg: &str) -> Option<RepeatCliMode> {
+    match arg {
+        "off" => Some(RepeatCliMode::Off),
+        "all" => Some(RepeatCliMode::All),
+        "one" => Some(RepeatCliMode::One),
+        _ => None,
+    }
+}
+
 fn parse_player_cli_at(args: &[String], pos: usize) -> Option<PlayerCliCmd> {
     let verb = args.get(pos + 1)?.as_str();
     match verb {
         "next" => Some(PlayerCliCmd::Next),
         "prev" => Some(PlayerCliCmd::Prev),
-        "play" => Some(PlayerCliCmd::Play),
+        "play" => match args.get(pos + 2).map(|s| s.as_str()) {
+            None => Some(PlayerCliCmd::Play),
+            Some(flag) if flag.starts_with('-') => None,
+            Some(extra) => {
+                if extra.is_empty() {
+                    return None;
+                }
+                Some(PlayerCliCmd::PlayOpaqueId(extra.to_string()))
+            }
+        },
         "pause" => Some(PlayerCliCmd::Pause),
+        "stop" => Some(PlayerCliCmd::Stop),
+        "shuffle" => Some(PlayerCliCmd::ShuffleQueue),
+        "repeat" => {
+            let m = parse_repeat_mode(args.get(pos + 2)?.as_str())?;
+            Some(PlayerCliCmd::Repeat(m))
+        }
+        "mute" => Some(PlayerCliCmd::Mute),
+        "unmute" => Some(PlayerCliCmd::Unmute),
+        "star" => Some(PlayerCliCmd::StarCurrent),
+        "unstar" => Some(PlayerCliCmd::UnstarCurrent),
+        "rating" => {
+            let raw = args.get(pos + 2)?;
+            let n: u8 = raw.parse().ok()?;
+            if n > 5 {
+                return None;
+            }
+            Some(PlayerCliCmd::Rating { stars: n })
+        }
+        "reload" => Some(PlayerCliCmd::ReloadPlayer),
         "seek" => {
             let raw = args.get(pos + 2)?;
             let delta_secs: i32 = raw.parse().ok()?;
@@ -547,6 +842,35 @@ pub fn parse_cli_command(args: &[String]) -> Option<CliCommand> {
                 _ => None,
             }
         }
+        "server" => {
+            let sub = args.get(pos + 2)?.as_str();
+            match sub {
+                "list" => Some(CliCommand::ServerList),
+                "set" => {
+                    let id = args.get(pos + 3)?;
+                    if id.is_empty() {
+                        return None;
+                    }
+                    Some(CliCommand::ServerSet(id.clone()))
+                }
+                _ => None,
+            }
+        }
+        "search" => {
+            let scope_raw = args.get(pos + 2)?.as_str();
+            let scope = match scope_raw {
+                "track" => SearchCliScope::Track,
+                "album" => SearchCliScope::Album,
+                "artist" => SearchCliScope::Artist,
+                _ => return None,
+            };
+            let tail = args.get(pos + 3..)?;
+            let query = tail.join(" ").trim().to_string();
+            if query.is_empty() {
+                return None;
+            }
+            Some(CliCommand::Search { scope, query })
+        }
         _ => parse_player_cli_at(args, pos).map(CliCommand::Player),
     }
 }
@@ -630,6 +954,26 @@ pub fn handle_cli_on_primary_instance<R: Runtime>(app: &AppHandle<R>, argv: &[St
             let _ = app.emit("cli:library-set", folder.clone());
             true
         }
+        Some(CliCommand::ServerList) => {
+            let _ = app.emit("cli:server-list", ());
+            true
+        }
+        Some(CliCommand::ServerSet(id)) => {
+            let _ = app.emit("cli:server-set", id.clone());
+            true
+        }
+        Some(CliCommand::Search { scope, query }) => {
+            let scope_s = match scope {
+                SearchCliScope::Track => "track",
+                SearchCliScope::Album => "album",
+                SearchCliScope::Artist => "artist",
+            };
+            let _ = app.emit(
+                "cli:search",
+                serde_json::json!({ "scope": scope_s, "query": query }),
+            );
+            true
+        }
         None => false,
     }
 }
@@ -678,6 +1022,7 @@ pub fn spawn_deferred_cli_argv_handler<R: Runtime>(app: &AppHandle<R>) {
                 let _ = handle.emit("cli:instant-mix", s);
             }
             CliCommand::LibraryList => {
+                let _ = std::fs::remove_file(cli_library_response_path());
                 let _ = handle.emit("cli:library-list", ());
                 let text = read_library_cli_response_blocking(Duration::from_secs(3));
                 print_library_cli_stdout(&text, json_out);
@@ -685,6 +1030,29 @@ pub fn spawn_deferred_cli_argv_handler<R: Runtime>(app: &AppHandle<R>) {
             CliCommand::LibrarySet(folder) => {
                 let _ = handle.emit("cli:library-set", folder.clone());
             }
+            CliCommand::ServerList => {
+                let _ = std::fs::remove_file(cli_server_list_path());
+                let _ = handle.emit("cli:server-list", ());
+                let text = read_server_list_cli_response_blocking(Duration::from_secs(3));
+                print_server_list_cli_stdout(&text, json_out);
+            }
+            CliCommand::ServerSet(id) => {
+                let _ = handle.emit("cli:server-set", id.clone());
+            }
+            CliCommand::Search { scope, query } => {
+                let _ = std::fs::remove_file(cli_search_response_path());
+                let scope_s = match scope {
+                    SearchCliScope::Track => "track",
+                    SearchCliScope::Album => "album",
+                    SearchCliScope::Artist => "artist",
+                };
+                let _ = handle.emit(
+                    "cli:search",
+                    serde_json::json!({ "scope": scope_s, "query": query }),
+                );
+                let text = read_search_cli_response_blocking(Duration::from_secs(12));
+                print_search_cli_stdout(&text, json_out);
+            }
         }
         if !quiet {
             println!("OK: {ok_line} (applied after startup)");
@@ -694,7 +1062,7 @@ pub fn spawn_deferred_cli_argv_handler<R: Runtime>(app: &AppHandle<R>) {
 
 pub fn describe_cli_command(cmd: &CliCommand) -> String {
     match cmd {
-        CliCommand::Player(c) => describe_player_cli_cmd(*c),
+        CliCommand::Player(c) => describe_player_cli_cmd(c),
         CliCommand::AudioDeviceList => "audio-device list".into(),
         CliCommand::AudioDeviceSet(None) => "audio-device set default".into(),
         CliCommand::AudioDeviceSet(Some(s)) => format!("audio-device set {s}"),
@@ -703,17 +1071,41 @@ pub fn describe_cli_command(cmd: &CliCommand) -> String {
         CliCommand::LibraryList => "library list".into(),
         CliCommand::LibrarySet(s) if s == "all" => "library set all".into(),
         CliCommand::LibrarySet(s) => format!("library set {s}"),
+        CliCommand::ServerList => "server list".into(),
+        CliCommand::ServerSet(s) => format!("server set {s}"),
+        CliCommand::Search { scope, query } => {
+            let sc = match scope {
+                SearchCliScope::Track => "track",
+                SearchCliScope::Album => "album",
+                SearchCliScope::Artist => "artist",
+            };
+            format!("search {sc} {query}")
+        }
     }
 }
 
-pub fn describe_player_cli_cmd(cmd: PlayerCliCmd) -> String {
+pub fn describe_player_cli_cmd(cmd: &PlayerCliCmd) -> String {
     match cmd {
         PlayerCliCmd::Next => "next track".into(),
         PlayerCliCmd::Prev => "previous track".into(),
         PlayerCliCmd::Play => "play".into(),
+        PlayerCliCmd::PlayOpaqueId(id) => format!("play {id}"),
         PlayerCliCmd::Pause => "pause".into(),
+        PlayerCliCmd::Stop => "stop".into(),
         PlayerCliCmd::Seek { delta_secs } => format!("seek {delta_secs:+} s"),
         PlayerCliCmd::Volume { percent } => format!("volume {percent}%"),
+        PlayerCliCmd::ShuffleQueue => "shuffle".into(),
+        PlayerCliCmd::Repeat(m) => match m {
+            RepeatCliMode::Off => "repeat off".into(),
+            RepeatCliMode::All => "repeat all".into(),
+            RepeatCliMode::One => "repeat one".into(),
+        },
+        PlayerCliCmd::Mute => "mute".into(),
+        PlayerCliCmd::Unmute => "unmute".into(),
+        PlayerCliCmd::StarCurrent => "star".into(),
+        PlayerCliCmd::UnstarCurrent => "unstar".into(),
+        PlayerCliCmd::Rating { stars } => format!("rating {stars}"),
+        PlayerCliCmd::ReloadPlayer => "reload".into(),
     }
 }
 
@@ -728,15 +1120,50 @@ pub fn emit_player_cli_cmd<R: Runtime>(app: &AppHandle<R>, cmd: PlayerCliCmd) {
         PlayerCliCmd::Play => {
             let _ = app.emit("media:play", ());
         }
+        PlayerCliCmd::PlayOpaqueId(id) => {
+            let _ = app.emit("cli:play-id", id);
+        }
         PlayerCliCmd::Pause => {
             let _ = app.emit("media:pause", ());
         }
+        PlayerCliCmd::Stop => {
+            let _ = app.emit("media:stop", ());
+        }
         PlayerCliCmd::Seek { delta_secs } => {
             let _ = app.emit("media:seek-relative", delta_secs);
         }
         PlayerCliCmd::Volume { percent } => {
             let _ = app.emit("media:set-volume", percent);
         }
+        PlayerCliCmd::ShuffleQueue => {
+            let _ = app.emit("cli:shuffle-queue", ());
+        }
+        PlayerCliCmd::Repeat(mode) => {
+            let s = match mode {
+                RepeatCliMode::Off => "off",
+                RepeatCliMode::All => "all",
+                RepeatCliMode::One => "one",
+            };
+            let _ = app.emit("cli:set-repeat", s);
+        }
+        PlayerCliCmd::Mute => {
+            let _ = app.emit("cli:mute", ());
+        }
+        PlayerCliCmd::Unmute => {
+            let _ = app.emit("cli:unmute", ());
+        }
+        PlayerCliCmd::StarCurrent => {
+            let _ = app.emit("cli:star-current", true);
+        }
+        PlayerCliCmd::UnstarCurrent => {
+            let _ = app.emit("cli:star-current", false);
+        }
+        PlayerCliCmd::Rating { stars } => {
+            let _ = app.emit("cli:set-rating-current", stars);
+        }
+        PlayerCliCmd::ReloadPlayer => {
+            let _ = app.emit("cli:reload-player", ());
+        }
     }
 }
 
@@ -771,6 +1198,12 @@ pub fn linux_try_forward_player_cli_secondary(args: &[String]) -> Result<LinuxPl
         Some(CliCommand::LibraryList) => {
             let _ = std::fs::remove_file(cli_library_response_path());
         }
+        Some(CliCommand::ServerList) => {
+            let _ = std::fs::remove_file(cli_server_list_path());
+        }
+        Some(CliCommand::Search { .. }) => {
+            let _ = std::fs::remove_file(cli_search_response_path());
+        }
         _ => {}
     }
 
@@ -803,6 +1236,22 @@ pub fn linux_try_forward_player_cli_secondary(args: &[String]) -> Result<LinuxPl
         if !wants_quiet(args) {
             println!("OK: library list");
         }
+    } else if let Some(CliCommand::ServerList) = parse_cli_command(args) {
+        let json_out = wants_cli_json_output(args);
+        let text = read_server_list_cli_response_blocking(Duration::from_secs(3));
+        print_server_list_cli_stdout(&text, json_out);
+        if !wants_quiet(args) {
+            println!("OK: server list");
+        }
+    } else if let Some(CliCommand::Search { .. }) = parse_cli_command(args) {
+        let json_out = wants_cli_json_output(args);
+        let text = read_search_cli_response_blocking(Duration::from_secs(12));
+        print_search_cli_stdout(&text, json_out);
+        if !wants_quiet(args) {
+            if let Some(cmd) = parse_cli_command(args) {
+                println!("OK: {}", describe_cli_command(&cmd));
+            }
+        }
     } else if !wants_quiet(args) {
         if let Some(cmd) = parse_cli_command(args) {
             println!("OK: {}", describe_cli_command(&cmd));

src-tauri/src/lib.rs

@@ -58,6 +58,18 @@ fn cli_publish_library_list(payload: serde_json::Value) -> Result<(), String> {
     crate::cli::write_library_cli_response(&payload)
 }
 
+/// Writes `psysonic-cli-servers.json` for `psysonic --player server list`.
+#[tauri::command]
+fn cli_publish_server_list(payload: serde_json::Value) -> Result<(), String> {
+    crate::cli::write_server_list_cli_response(&payload)
+}
+
+/// Writes `psysonic-cli-search.json` for `psysonic --player search …`.
+#[tauri::command]
+fn cli_publish_search_results(payload: serde_json::Value) -> Result<(), String> {
+    crate::cli::write_search_cli_response(&payload)
+}
+
 /// Toggle native window decorations at runtime (Linux custom title bar opt-out).
 #[tauri::command]
 fn set_window_decorations(enabled: bool, app_handle: tauri::AppHandle) {
@@ -2109,6 +2121,30 @@ fn build_tray_icon(app: &tauri::AppHandle) -> tauri::Result<TrayIcon> {
         .build(app)
 }
 
+/// Creates the tray icon, or `None` if the OS cannot host one.
+///
+/// On Linux, `libayatana-appindicator3` / `libappindicator3` may be absent (minimal
+/// installs, wrong `LD_LIBRARY_PATH`). The `tray-icon` stack can **panic** on `dlopen`
+/// failure instead of returning `Err`, so we catch unwind and keep the app running
+/// (e.g. cold start with `--player` still works without tray libraries).
+fn try_build_tray_icon(app: &tauri::AppHandle) -> Option<TrayIcon> {
+    let app = app.clone();
+    match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| build_tray_icon(&app))) {
+        Ok(Ok(tray)) => Some(tray),
+        Ok(Err(e)) => {
+            eprintln!("[Psysonic] System tray unavailable: {e}");
+            None
+        }
+        Err(_) => {
+            eprintln!(
+                "[Psysonic] System tray unavailable — missing libayatana-appindicator3 or libappindicator3 \
+                 (install the distro package or set LD_LIBRARY_PATH)"
+            );
+            None
+        }
+    }
+}
+
 /// Show (`true`) or fully remove (`false`) the system-tray icon.
 ///
 /// The command is strictly idempotent:
@@ -2132,7 +2168,12 @@ fn toggle_tray_icon(
         if guard.is_some() {
             return Ok(());
         }
-        *guard = Some(build_tray_icon(&app).map_err(|e| e.to_string())?);
+        let Some(tray) = try_build_tray_icon(&app) else {
+            return Err(
+                "Tray icon could not be created (missing system libraries on Linux).".into(),
+            );
+        };
+        *guard = Some(tray);
     } else if let Some(tray) = guard.take() {
         // Hide synchronously before dropping so the OS processes the removal
         // before any subsequent show=true call can create a new icon.
@@ -2267,11 +2308,13 @@ pub fn run() {
             }
 
             // ── System tray ───────────────────────────────────────────────
-            // Always build on startup; the frontend calls toggle_tray_icon(false)
+            // Always build on startup when possible; the frontend calls toggle_tray_icon(false)
             // immediately after load if the user has disabled the tray icon.
+            // May be skipped if Ayatana/AppIndicator libraries are missing (no panic).
             {
-                let tray = build_tray_icon(app.handle())?;
-                *app.state::<TrayState>().lock().unwrap() = Some(tray);
+                if let Some(tray) = try_build_tray_icon(app.handle()) {
+                    *app.state::<TrayState>().lock().unwrap() = Some(tray);
+                }
             }
 
             // ── MPRIS2 / OS media controls via souvlaki ──────────────────
@@ -2415,6 +2458,8 @@ pub fn run() {
             exit_app,
             cli_publish_player_snapshot,
             cli_publish_library_list,
+            cli_publish_server_list,
+            cli_publish_search_results,
             set_window_decorations,
             no_compositing_mode,
             is_tiling_wm_cmd,