Merge branch 'windows-support' into minor-fixes

Author: Mnem42

debian/changelog

@@ -0,0 +1,5 @@
+rustcast (0.5.2) unstable; urgency=medium
+
+  * Fix app discovery: [Merge pull request #149 from unsecretised/fix-app…]
+
+ -- Umang Surana <no1umang@gmail.com>  Fri, 13 Feb 2026 07:23:44 +0200

debian/control

@@ -0,0 +1,11 @@
+Source: rustcast
+Section: utils
+Priority: optional
+Maintainer: Umang Surana
+Build-Depends: debhelper-compat (= 13), pkg-config, libgtk-3-dev, libssl-dev, libayatana-appindicator3-dev
+Standards-Version: 4.5.0
+
+Package: rustcast
+Architecture: any
+Depends: ${shlibs:Depends}, ${misc:Depends}, libgtk-3-0, libayatana-appindicator3-1 
+Description: An open source alternative to Raycast, and in rust

debian/rules

@@ -0,0 +1,13 @@
+#!/usr/bin/make -f
+
+export PATH := $(HOME)/.cargo/bin:$(PATH)
+
+%:
+	dh $@
+
+override_dh_auto_build:
+	cargo build --release --target x86_64-unknown-linux-gnu
+
+override_dh_auto_install:
+	install -d $(CURDIR)/debian/rustcast/usr/bin
+	install -m 755 target/x86_64-unknown-linux-gnu/release/rustcast $(CURDIR)/debian/rustcast/usr/bin/rustcast

rust-toolchain.toml

@@ -1,5 +1,5 @@
 [toolchain]
 channel = "stable"
 components = ["rustfmt", "clippy", "cargo"]
-targets = ["x86_64-apple-darwin", "x86_64-pc-windows-msvc"]
+targets = ["x86_64-apple-darwin", "x86_64-pc-windows-msvc", "x86_64-unknown-linux-gnu"]
 profile = "default"

src/app/tile/elm.rs

@@ -76,6 +76,8 @@ pub fn new(
     #[cfg(not(target_os = "linux"))] hotkey: HotKey,
     config: &Config,
 ) -> (Tile, Task<Message>) {
+    tracing::trace!(target: "elm_init", "Initing ELM");
+    
     #[allow(unused_mut)]
     let mut settings = default_settings();
 
@@ -89,6 +91,8 @@ pub fn new(
         settings.position = Position::Specific(pos);
     }
 
+    tracing::trace!(target: "elm_init", "Opening window");
+    
     // id unused on windows, but not macos
     #[allow(unused)]
     let (id, open) = window::open(settings);

src/app/tile/update.rs

@@ -23,7 +23,7 @@ use crate::utils::index_installed_apps;
 
 #[allow(clippy::too_many_lines)]
 pub fn handle_update(tile: &mut Tile, message: Message) -> Task<Message> {
-    tracing::trace!("Handling update (message: {:?})", message);
+    tracing::trace!(target: "update", "{:?}", message);
 
     match message {
         Message::OpenWindow => {

src/app_finding/linux.rs

@@ -0,0 +1,129 @@
+use std::{fs, path::Path};
+
+use freedesktop_desktop_entry::DesktopEntry;
+use glob::glob;
+use iced::widget::image::Handle;
+use image::{ImageReader, RgbaImage};
+use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
+
+use crate::{
+    app::{
+        apps::{App, AppCommand, AppData},
+        tile::elm::default_app_paths,
+    },
+    config::Config,
+};
+
+pub fn get_installed_linux_apps(config: &Config) -> Vec<App> {
+    let paths = default_app_paths();
+    let store_icons = config.theme.show_icons;
+
+    let apps: Vec<App> = paths
+        .par_iter()
+        .map(|path| {
+            let mut pattern = path.clone();
+            if !pattern.ends_with('/') {
+                pattern.push('/');
+            }
+            pattern.push_str("**/*.desktop");
+
+            get_installed_apps_glob(&pattern, store_icons)
+        })
+        .flatten()
+        .collect();
+
+    apps
+}
+
+fn get_installed_apps_glob(pattern: &str, store_icons: bool) -> Vec<App> {
+    glob(pattern)
+        .unwrap()
+        .flatten()
+        .flat_map(|entry| get_installed_apps(entry.as_path(), store_icons))
+        .collect()
+}
+
+fn get_installed_apps(path: &Path, store_icons: bool) -> Vec<App> {
+    let mut apps = Vec::new();
+
+    let Ok(content) = fs::read_to_string(path) else {
+        return apps;
+    };
+
+    let Ok(de) = DesktopEntry::from_str(path, &content, None::<&[String]>) else {
+        return apps;
+    };
+
+    if de.no_display() || de.hidden() {
+        return apps;
+    }
+
+    let Some(name) = de.desktop_entry("Name") else {
+        return apps;
+    };
+    let desc = de.desktop_entry("Comment").unwrap_or("");
+    let Some(exec) = de.exec() else {
+        return apps;
+    };
+
+    let exec = exec.to_string();
+    let mut parts = exec.split_whitespace().filter(|p| !p.starts_with("%"));
+
+    let Some(cmd) = parts.next() else {
+        return apps;
+    };
+
+    let args = parts.map(str::to_owned).collect::<Vec<_>>().join(" ");
+
+    let icon = if store_icons {
+        de.icon()
+            .map(str::to_owned)
+            .and_then(|icon_name| find_icon_handle(&icon_name))
+    } else {
+        None
+    };
+
+    apps.push(App::new(
+        &name,
+        &name.to_lowercase(),
+        &desc,
+        AppData::Command {
+            command: cmd.to_string(),
+            alias: args,
+            icon,
+        },
+    ));
+
+    apps
+}
+
+pub fn handle_from_png(path: &Path) -> Option<Handle> {
+    let img = ImageReader::open(path).ok()?.decode().ok()?.to_rgba8();
+    let image = RgbaImage::from_raw(img.width(), img.height(), img.to_vec())?;
+    Some(Handle::from_rgba(
+        image.width(),
+        image.height(),
+        image.into_raw(),
+    ))
+}
+
+fn find_icon_handle(name: &str) -> Option<Handle> {
+    let paths = default_app_paths();
+
+    for dir in paths {
+        let mut pattern = dir.clone();
+
+        if !pattern.ends_with('/') {
+            pattern.push('/');
+        }
+        pattern.push_str(&format!("icons/**/{}*", name));
+
+        for entry in glob(&pattern).ok()?.flatten() {
+            if let Some(handle) = handle_from_png(&entry) {
+                return Some(handle);
+            }
+        }
+    }
+
+    None
+}

src/app_finding/macos.rs

@@ -0,0 +1,147 @@
+use std::path::PathBuf;
+use std::process::exit;
+use crate::{app::apps::App, config::Config, utils::index_installed_apps};
+
+
+fn get_installed_apps(dir: impl AsRef<Path>, store_icons: bool) -> Vec<App> {
+    let entries: Vec<_> = fs::read_dir(dir.as_ref())
+        .unwrap_or_else(|x| {
+            tracing::error!(
+                "An error occurred while reading dir ({}) {}",
+                dir.as_ref().to_str().unwrap_or(""),
+                x
+            );
+            exit(-1)
+        })
+        .filter_map(|x| x.ok())
+        .collect();
+
+    entries
+        .into_par_iter()
+        .filter_map(|x| {
+            let file_type = x.file_type().unwrap_or_else(|e| {
+                tracing::error!("Failed to get file type: {}", e.to_string());
+                exit(-1)
+            });
+            if !file_type.is_dir() {
+                return None;
+            }
+
+            let file_name_os = x.file_name();
+            let file_name = file_name_os.into_string().unwrap_or_else(|e| {
+                tracing::error!("Failed to to get file_name_os: {}", e.to_string_lossy());
+                exit(-1)
+            });
+            if !file_name.ends_with(".app") {
+                return None;
+            }
+
+            let path = x.path();
+            let path_str = path.to_str().map(|x| x.to_string()).unwrap_or_else(|| {
+                tracing::error!("Unable to get file_name");
+                exit(-1)
+            });
+
+            let icons = if store_icons {
+                match fs::read_to_string(format!("{}/Contents/Info.plist", path_str)).map(
+                    |content| {
+                        let icon_line = content
+                            .lines()
+                            .scan(false, |expect_next, line| {
+                                if *expect_next {
+                                    *expect_next = false;
+                                    // Return this line to the iterator
+                                    return Some(Some(line));
+                                }
+
+                                if line.trim() == "<key>CFBundleIconFile</key>" {
+                                    *expect_next = true;
+                                }
+
+                                // For lines that are not the one after the key, return None to skip
+                                Some(None)
+                            })
+                            .flatten() // remove the Nones
+                            .next()
+                            .map(|x| {
+                                x.trim()
+                                    .strip_prefix("<string>")
+                                    .unwrap_or("")
+                                    .strip_suffix("</string>")
+                                    .unwrap_or("")
+                            });
+
+                        handle_from_icns(Path::new(&format!(
+                            "{}/Contents/Resources/{}",
+                            path_str,
+                            icon_line.unwrap_or("AppIcon.icns")
+                        )))
+                    },
+                ) {
+                    Ok(Some(a)) => Some(a),
+                    _ => {
+                        // Fallback method
+                        let direntry = fs::read_dir(format!("{}/Contents/Resources", path_str))
+                            .into_iter()
+                            .flatten()
+                            .filter_map(|x| {
+                                let file = x.ok()?;
+                                let name = file.file_name();
+                                let file_name = name.to_str()?;
+                                if file_name.ends_with(".icns") {
+                                    Some(file.path())
+                                } else {
+                                    None
+                                }
+                            })
+                            .collect::<Vec<PathBuf>>();
+
+                        if direntry.len() > 1 {
+                            let icns_vec = direntry
+                                .iter()
+                                .filter(|x| x.ends_with("AppIcon.icns"))
+                                .collect::<Vec<&PathBuf>>();
+                            handle_from_icns(icns_vec.first().unwrap_or(&&PathBuf::new()))
+                        } else if !direntry.is_empty() {
+                            handle_from_icns(direntry.first().unwrap_or(&PathBuf::new()))
+                        } else {
+                            None
+                        }
+                    }
+                }
+            } else {
+                None
+            };
+
+            let name = file_name.strip_suffix(".app").unwrap().to_string();
+            Some(App::new_executable(
+                &name,
+                &name.to_lowercase(),
+                "Application",
+                path,
+                icons,
+            ))
+        })
+        .collect()
+}
+
+pub fn get_installed_macos_apps(config: &Config) -> anyhow::Result<Vec<App>> {
+    let store_icons = config.theme.show_icons;
+    let user_local_path = std::env::var("HOME").unwrap() + "/Applications/";
+    let paths: Vec<String> = vec![
+        "/Applications/".to_string(),
+        user_local_path.to_string(),
+        "/System/Applications/".to_string(),
+        "/System/Applications/Utilities/".to_string(),
+    ];
+
+    let mut apps = index_installed_apps(config)?;
+    apps.par_extend(
+        paths
+            .par_iter()
+            .map(|path| get_installed_apps(path, store_icons))
+            .flatten(),
+    );
+
+    Ok(apps)
+}

src/app_finding/mod.rs

@@ -0,0 +1,6 @@
+#[cfg(target_os = "linux")]
+mod linux;
+#[cfg(target_os = "macos")]
+mod macos;
+#[cfg(target_os = "windows")]
+mod windows;