fix: stabilize launcher behavior and local installs

- reduce idle polling in the launcher event loops and extension navigation\n- refresh app icons after async extraction and fix main-thread icon extraction\n- add stable local signing and install scripts so rebuilds keep a consistent macOS identity

Author: panosAthDBX

README.md

@@ -44,6 +44,25 @@ cargo build --release
 cargo run
 ```
 
+## Local Install
+
+```bash
+# Create a stable local code-signing identity once
+./scripts/create-dev-signing-identity.sh
+
+# Build a signed-or-ad-hoc app bundle in build/PhotonCast.app
+./scripts/release-build.sh
+
+# Replace the installed app in /Applications and relaunch it
+./scripts/install-app.sh
+```
+
+If PhotonCast is only ad-hoc signed, macOS tracks it by `cdhash`, so Accessibility
+and Calendar permissions may need to be re-granted after rebuilds. A stable signing
+identity avoids that churn. `create-dev-signing-identity.sh` provisions a local
+`PhotonCast Local Dev` identity, and `release-build.sh` / `sign.sh` automatically
+use it when `~/.config/photoncast/dev-signing.env` is present.
+
 ## Project Structure
 
 ```

crates/photoncast/src/extension_views/navigation.rs

@@ -312,7 +312,9 @@ impl NavigationContainer {
     /// Starts polling for external updates from ViewHandle.
     fn start_update_polling(&self, cx: &mut ViewContext<Self>) {
         cx.spawn(|this, mut cx| async move {
-            const POLL_INTERVAL_MS: u64 = 16; // ~60 FPS
+            // Extension updates are not animation frames; keep this low-frequency
+            // while the actual transition animation uses its own 16ms timer.
+            const POLL_INTERVAL_MS: u64 = 100;
 
             loop {
                 cx.background_executor()

crates/photoncast/src/icon_cache.rs

@@ -129,7 +129,7 @@ pub fn clear_icon(app_path: &Path) {
 /// Extracts an app icon to the cache path.
 ///
 /// Spawns a synchronous `sips` process to convert `.icns` to `.png`.
-/// Must be called from a background thread (see [`get_icon_static`]).
+/// This is used as a fallback when the richer `NSWorkspace` path fails.
 pub fn extract_icon(app_path: &Path, cache_path: &Path) -> Option<PathBuf> {
     // Try to find the icon in the app bundle
     let icns_path = app_path.join("Contents/Resources/AppIcon.icns");
@@ -199,15 +199,20 @@ pub fn extract_icon(app_path: &Path, cache_path: &Path) -> Option<PathBuf> {
     None
 }
 
-/// Static version of [`get_icon`] for use in async context.
-///
-/// # Threading Model
-///
-/// This function performs synchronous I/O (filesystem checks and `sips` process
-/// spawning). It must only be called from a background thread — never from the
-/// main/UI thread. All current call sites dispatch through
-/// `cx.background_executor().spawn()` which satisfies this requirement.
-pub fn get_icon_static(app_path: &Path) -> Option<PathBuf> {
+fn extract_best_available_icon(app_path: &Path, cache_path: &Path) -> Option<PathBuf> {
+    if crate::platform::save_app_icon_as_png(app_path, cache_path, 64) {
+        tracing::debug!(
+            "Extracted icon for {} -> {}",
+            app_path.display(),
+            cache_path.display()
+        );
+        Some(cache_path.to_path_buf())
+    } else {
+        extract_icon(app_path, cache_path)
+    }
+}
+
+fn get_or_extract_icon(app_path: &Path) -> Option<PathBuf> {
     let cache_dir = cache_dir();
 
     // Ensure cache directory exists
@@ -236,52 +241,20 @@ pub fn get_icon_static(app_path: &Path) -> Option<PathBuf> {
         }
     }
 
-    // Extract icon using platform-specific code
-    extract_icon(app_path, &cached_path)
+    extract_best_available_icon(app_path, &cached_path)
+}
+
+/// Static version of [`get_icon`] for use in async context.
+///
+/// Safe to call from a background thread. AppKit icon extraction is marshalled
+/// onto the main queue internally, with `.icns` conversion as a fallback.
+pub fn get_icon_static(app_path: &Path) -> Option<PathBuf> {
+    get_or_extract_icon(app_path)
 }
 
 /// Gets or extracts the icon for an app bundle as PNG.
 ///
-/// Uses `NSWorkspace` to handle all icon formats including asset catalogs.
+/// Safe to call from any thread.
 pub fn get_icon(app_path: &Path) -> Option<PathBuf> {
-    let cache_dir = cache_dir();
-
-    // Ensure cache directory exists
-    if let Err(e) = std::fs::create_dir_all(&cache_dir) {
-        tracing::warn!("Failed to create icon cache dir: {}", e);
-        return None;
-    }
-
-    let cached_path = cached_icon_filename(app_path);
-
-    // Return cached icon if it exists and is fresh
-    if cached_path.exists() {
-        // Check if app is newer than cached icon
-        let app_modified = std::fs::metadata(app_path)
-            .ok()
-            .and_then(|m| m.modified().ok());
-        let cached_modified = std::fs::metadata(&cached_path)
-            .ok()
-            .and_then(|m| m.modified().ok());
-
-        match (app_modified, cached_modified) {
-            (Some(app_time), Some(cache_time)) if cache_time >= app_time => {
-                return Some(cached_path);
-            },
-            _ => {}, // Re-extract if we can't determine freshness
-        }
-    }
-
-    // Extract icon using NSWorkspace (handles all icon formats)
-    if crate::platform::save_app_icon_as_png(app_path, &cached_path, 64) {
-        tracing::debug!(
-            "Extracted icon for {} -> {}",
-            app_path.display(),
-            cached_path.display()
-        );
-        Some(cached_path)
-    } else {
-        tracing::warn!("Failed to extract icon for {}", app_path.display());
-        None
-    }
+    get_or_extract_icon(app_path)
 }

crates/photoncast/src/launcher/indexing.rs

@@ -12,7 +12,6 @@ impl LauncherWindow {
         // but GPUI uses its own async executor
         let (tx, rx) = std::sync::mpsc::channel();
 
-        let photoncast_app_for_icons = Arc::clone(&photoncast_app);
         std::thread::spawn(move || {
             tracing::info!("Starting application indexing...");
 
@@ -23,42 +22,7 @@ impl LauncherWindow {
             });
 
             // Send scan results immediately so UI becomes responsive
-            let apps_for_icons = result.as_ref().ok().cloned();
             let _ = tx.send(result);
-
-            // Now extract icons in the same background thread (doesn't block UI)
-            if let Some(apps) = apps_for_icons {
-                tracing::info!(
-                    "Starting background icon extraction for {} apps",
-                    apps.len()
-                );
-                let start = std::time::Instant::now();
-                let mut extracted = 0;
-                let mut cached = 0;
-
-                for app in &apps {
-                    // Extract or get cached icon
-                    if let Some(icon_path) = Self::get_app_icon_path(&app.path) {
-                        // Update the app's icon in shared state
-                        photoncast_app_for_icons
-                            .write()
-                            .update_app_icon(&app.bundle_id.to_string(), icon_path);
-
-                        if Self::get_cached_icon_path(&app.path).is_some() {
-                            cached += 1;
-                        } else {
-                            extracted += 1;
-                        }
-                    }
-                }
-
-                tracing::info!(
-                    "Icon extraction complete: {} cached, {} extracted in {:?}",
-                    cached,
-                    extracted,
-                    start.elapsed()
-                );
-            }
         });
 
         // Poll for results in GPUI's async context
@@ -73,6 +37,7 @@ impl LauncherWindow {
                 match rx.try_recv() {
                     Ok(Ok(apps)) => {
                         let app_count = apps.len();
+                        let apps_for_icons = apps.clone();
                         tracing::info!("Indexed {} applications", app_count);
 
                         // Update the PhotonCast app with indexed apps
@@ -87,6 +52,43 @@ impl LauncherWindow {
                             this.start_app_watching(cx);
                             cx.notify();
                         });
+
+                        let photoncast_app_for_icons = Arc::clone(&photoncast_app);
+                        let this_for_icons = this.clone();
+                        cx.spawn(|mut cx| async move {
+                            tracing::info!(
+                                "Starting background icon extraction for {} apps",
+                                apps_for_icons.len()
+                            );
+
+                            let mut updated_icons = 0usize;
+                            for app in apps_for_icons {
+                                let app_path = app.path.clone();
+                                let bundle_id = app.bundle_id.to_string();
+
+                                let icon_result = cx
+                                    .background_executor()
+                                    .spawn(async move { Self::get_app_icon_path_static(&app_path) })
+                                    .await;
+
+                                if let Some(icon_path) = icon_result {
+                                    photoncast_app_for_icons
+                                        .write()
+                                        .update_app_icon(&bundle_id, icon_path);
+                                    updated_icons += 1;
+
+                                    let _ = this_for_icons.update(&mut cx, |this, cx| {
+                                        this.refresh_visible_app_icons(cx);
+                                    });
+                                }
+                            }
+
+                            tracing::info!(
+                                "Background icon extraction complete: {} icons updated",
+                                updated_icons
+                            );
+                        })
+                        .detach();
                         break;
                     },
                     Ok(Err(e)) => {
@@ -156,30 +158,44 @@ impl LauncherWindow {
                 }
             });
         });
+        let event_rx = Arc::new(std::sync::Mutex::new(event_rx));
 
         // Process watch events in GPUI's async context
         cx.spawn(|this, mut cx| async move {
+            const WATCH_EVENT_TIMEOUT_MS: u64 = 500;
+
             loop {
-                // Poll for events periodically
-                cx.background_executor()
-                    .timer(Duration::from_millis(100))
-                    .await;
+                let next_events = {
+                    let event_rx = Arc::clone(&event_rx);
+                    cx.background_executor().spawn(async move {
+                        let receiver = event_rx.lock().expect("watch event receiver poisoned");
+                        match receiver.recv_timeout(Duration::from_millis(WATCH_EVENT_TIMEOUT_MS)) {
+                            Ok(first_event) => {
+                                let mut events = vec![first_event];
+                                while let Ok(event) = receiver.try_recv() {
+                                    events.push(event);
+                                }
+                                Ok(events)
+                            },
+                            Err(err) => Err(err),
+                        }
+                    })
+                }
+                .await;
 
-                // Process all pending events
-                loop {
-                    match event_rx.try_recv() {
-                        Ok(event) => {
+                match next_events {
+                    Ok(events) => {
+                        for event in events {
                             Self::handle_watch_event(&this, &mut cx, &photoncast_app, event).await;
-                        },
-                        Err(std::sync::mpsc::TryRecvError::Empty) => {
-                            // No more events, wait for next poll
-                            break;
-                        },
-                        Err(std::sync::mpsc::TryRecvError::Disconnected) => {
-                            tracing::info!("Watcher thread disconnected");
-                            return;
-                        },
-                    }
+                        }
+                    },
+                    Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {
+                        // No watch events before timeout, continue waiting.
+                    },
+                    Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => {
+                        tracing::info!("Watcher thread disconnected");
+                        return;
+                    },
                 }
             }
         })
@@ -271,9 +287,8 @@ impl LauncherWindow {
                                 .write()
                                 .update_app_icon(&bundle_id, icon_path);
 
-                            // Notify UI that icon is now available
-                            let _ = this_for_icon.update(&mut cx, |_this, cx| {
-                                cx.notify();
+                            let _ = this_for_icon.update(&mut cx, |this, cx| {
+                                this.refresh_visible_app_icons(cx);
                             });
                         }
                     })
@@ -327,9 +342,8 @@ impl LauncherWindow {
                                 .write()
                                 .update_app_icon(&bundle_id, icon_path);
 
-                            // Notify UI that icon has been updated
-                            let _ = this_for_icon.update(&mut cx, |_this, cx| {
-                                cx.notify();
+                            let _ = this_for_icon.update(&mut cx, |this, cx| {
+                                this.refresh_visible_app_icons(cx);
                             });
                         }
                     })
@@ -415,6 +429,51 @@ impl LauncherWindow {
         crate::icon_cache::get_cached_icon_path(app_path)
     }
 
+    fn backfill_cached_icon_paths(results: &mut [SearchResult]) -> bool {
+        let mut changed = false;
+
+        for result in results {
+            let SearchAction::LaunchApp { path, .. } = &result.action else {
+                continue;
+            };
+
+            let IconSource::AppIcon { icon_path, .. } = &mut result.icon else {
+                continue;
+            };
+
+            if icon_path.is_some() {
+                continue;
+            }
+
+            if let Some(cached_path) = Self::get_cached_icon_path(path) {
+                *icon_path = Some(cached_path);
+                changed = true;
+            }
+        }
+
+        changed
+    }
+
+    fn refresh_visible_app_icons(&mut self, cx: &mut ViewContext<Self>) {
+        let suggestions_changed = Self::backfill_cached_icon_paths(&mut self.search.suggestions);
+        let core_changed = Self::backfill_cached_icon_paths(&mut self.search.core_results);
+
+        if !(suggestions_changed || core_changed) {
+            return;
+        }
+
+        if !matches!(self.search.mode, SearchMode::Calendar { .. }) {
+            self.search.results = self
+                .search
+                .core_results
+                .iter()
+                .map(Self::search_result_to_result_item)
+                .collect();
+        }
+
+        cx.notify();
+    }
+
     /// Converts an icon source to a display emoji (fallback)
     pub(super) fn icon_to_emoji(icon: &IconSource) -> SharedString {
         match icon {