fix hooks

yujonglee · yujonglee · commit 51cc33cf5497 · 2025-12-10T19:06:04.000+09:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -177,6 +177,7 @@ serde_bytes = "0.11.15"
 serde_json = "1"
 serde_qs = "1.0.0-rc.3"
 serde_yaml = "0.9"
+shellexpand = "3"
 similar = "2.7.0"
 statig = "0.4"
 strum = "0.26"
diff --git a/apps/desktop/src/store/zustand/listener/general.ts b/apps/desktop/src/store/zustand/listener/general.ts
@@ -1,9 +1,10 @@
-import { getName } from "@tauri-apps/api/app";
+import { getIdentifier } from "@tauri-apps/api/app";
 import { appDataDir } from "@tauri-apps/api/path";
 import { Effect, Exit } from "effect";
 import { create as mutate } from "mutative";
 import type { StoreApi } from "zustand";
 
+import { commands as detectCommands } from "@hypr/plugin-detect";
 import { commands as hooksCommands } from "@hypr/plugin-hooks";
 import {
   commands as listenerCommands,
@@ -201,18 +202,30 @@ export const createGeneralSlice = <
         }),
       );
 
-      Promise.all([appDataDir(), getName().catch(() => "com.hyprnote.app")])
-        .then(([dataDirPath, appName]) => {
+      Promise.all([
+        appDataDir(),
+        detectCommands
+          .listMicUsingApplications()
+          .then((r) =>
+            r.status === "ok" ? r.data.map((app) => app.id) : null,
+          ),
+        getIdentifier().catch(() => "com.hyprnote.stable"),
+      ])
+        .then(([dataDirPath, micUsingApps, bundleId]) => {
           const sessionPath = `${dataDirPath}/hyprnote/sessions/${targetSessionId}`;
-          return hooksCommands.runEventHooks({
-            beforeListeningStarted: {
-              args: {
-                resource_dir: sessionPath,
-                app_hyprnote: appName,
-                app_meeting: null,
+          const app_meeting = micUsingApps?.[0] ?? null;
+
+          hooksCommands
+            .runEventHooks({
+              beforeListeningStarted: {
+                args: {
+                  resource_dir: sessionPath,
+                  app_hyprnote: bundleId,
+                  app_meeting,
+                },
               },
-            },
-          });
+            })
+            .catch(console.error);
         })
         .catch((error) => {
           console.error("[hooks] BeforeListeningStarted failed:", error);
@@ -274,15 +287,15 @@ export const createGeneralSlice = <
           if (sessionId) {
             Promise.all([
               appDataDir(),
-              getName().catch(() => "com.hyprnote.app"),
+              getIdentifier().catch(() => "com.hyprnote.app"),
             ])
-              .then(([dataDirPath, appName]) => {
+              .then(([dataDirPath, bundleId]) => {
                 const sessionPath = `${dataDirPath}/hyprnote/sessions/${sessionId}`;
                 return hooksCommands.runEventHooks({
                   afterListeningStopped: {
                     args: {
                       resource_dir: sessionPath,
-                      app_hyprnote: appName,
+                      app_hyprnote: bundleId,
                       app_meeting: null,
                     },
                   },
diff --git a/apps/web/content/docs/developers/4.hooks.mdx b/apps/web/content/docs/developers/4.hooks.mdx
@@ -43,8 +43,8 @@ exit 0
 Every hook command receives additional CLI flags based on the event type. For listening-related hooks, these include:
 
 - `--resource-dir`: Path to the session's resource directory
-- `--app-hyprnote`: Application identifier (e.g., `com.hyprnote.app`)
-- `--app-meeting`: Optional meeting-specific data (if available)
+- `--app-hyprnote`: Hyprnote application identifier (e.g., `com.hyprnote.stable`)
+- `--app-meeting`: Optional Meeting application identifier (if available)
 
 Your scripts can parse these arguments to access session metadata, or simply ignore them if not needed.
 
@@ -59,17 +59,14 @@ cp scripts/yabai.sh "$HOME/Library/Application Support/hyprnote/hooks/yabai.sh"
 chmod +x "$HOME/Library/Application Support/hyprnote/hooks/yabai.sh"
 ```
 
-Then configure your hooks to automatically tile Hyprnote when recording starts and stops:
+Then configure your hooks to automatically tile Hyprnote when recording starts:
 
 ```json
 {
   "version": 0,
   "hooks": {
     "beforeListeningStarted": [
-      { "command": "$HOME/Library/Application Support/hyprnote/hooks/yabai.sh --app Hyprnote --position left" }
-    ],
-    "afterListeningStopped": [
-      { "command": "$HOME/Library/Application Support/hyprnote/hooks/yabai.sh --app Hyprnote --position right" }
+      { "command": "$HOME/dev/hyprnote/scripts/yabai.sh" }
     ]
   }
 }
diff --git a/crates/detect/src/list/macos.rs b/crates/detect/src/list/macos.rs
@@ -47,36 +47,53 @@ pub fn list_installed_apps() -> Vec<InstalledApp> {
 
 #[cfg(target_os = "macos")]
 pub fn list_mic_using_apps() -> Vec<InstalledApp> {
-    let processes = ca::System::processes().ok().unwrap();
+    let Some(processes) = ca::System::processes().ok() else {
+        return Vec::new();
+    };
 
     let mut out = Vec::<InstalledApp>::new();
     for p in processes {
-        if !p.is_running_input().unwrap_or(false) {
+        if let Ok(false) = p.is_running_input() {
             continue;
         }
 
-        if let Ok(pid) = p.pid() {
-            if let Some(running_app) = cidre::ns::RunningApp::with_pid(pid) {
-                let bundle_id = running_app
-                    .bundle_id()
-                    .map(|s| s.to_string())
-                    .unwrap_or_default();
-                let localized_name = running_app
-                    .localized_name()
-                    .map(|s| s.to_string())
-                    .unwrap_or_default();
-
-                out.push(InstalledApp {
-                    id: bundle_id,
-                    name: localized_name,
-                });
-            }
+        let bundle_id = p
+            .bundle_id()
+            .ok()
+            .map(|s| s.to_string())
+            .unwrap_or_default();
+        if bundle_id.is_empty() {
+            continue;
         }
+
+        let (resolved_bundle_id, name) = resolve_to_parent_app(&bundle_id);
+
+        out.push(InstalledApp {
+            id: resolved_bundle_id,
+            name,
+        });
     }
 
     out
 }
 
+fn resolve_to_parent_app(bundle_id: &str) -> (String, String) {
+    let try_resolve = |id: &str| -> Option<String> {
+        cidre::ns::RunningApp::with_bundle_id(&cidre::ns::String::with_str(id))
+            .first()
+            .and_then(|app| app.localized_name().map(|s| s.to_string()))
+    };
+
+    if let Some((parent, _)) = bundle_id.rsplit_once('.') {
+        if let Some(name) = try_resolve(parent) {
+            return (parent.to_string(), name);
+        }
+    }
+
+    let name = try_resolve(bundle_id).unwrap_or_else(|| bundle_id.to_string());
+    (bundle_id.to_string(), name)
+}
+
 fn get_app_info(app_path: &std::path::Path) -> Option<InstalledApp> {
     let info_plist_path = app_path.join("Contents/Info.plist");
 
diff --git a/crates/detect/src/list/mod.rs b/crates/detect/src/list/mod.rs
@@ -2,22 +2,39 @@
 mod macos;
 
 #[cfg(target_os = "macos")]
-pub use macos::{list_installed_apps, list_mic_using_apps};
+pub use macos::list_installed_apps;
 
 #[cfg(target_os = "linux")]
 mod linux;
 
 #[cfg(target_os = "linux")]
-pub use linux::{list_installed_apps, list_mic_using_apps};
+pub use linux::list_installed_apps;
 
 #[cfg(not(any(target_os = "macos", target_os = "linux")))]
 pub fn list_installed_apps() -> Vec<InstalledApp> {
     Vec::new()
 }
 
-#[cfg(not(any(target_os = "macos", target_os = "linux")))]
 pub fn list_mic_using_apps() -> Vec<InstalledApp> {
-    Vec::new()
+    let apps = {
+        #[cfg(target_os = "macos")]
+        {
+            macos::list_mic_using_apps()
+        }
+        #[cfg(target_os = "linux")]
+        {
+            linux::list_mic_using_apps()
+        }
+
+        #[cfg(not(any(target_os = "macos", target_os = "linux")))]
+        {
+            Vec::new()
+        }
+    };
+
+    apps.into_iter()
+        .filter(|app| !app.id.to_lowercase().contains("hyprnote"))
+        .collect()
 }
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize, specta::Type)]
diff --git a/plugins/hooks/Cargo.toml b/plugins/hooks/Cargo.toml
@@ -12,6 +12,7 @@ tauri-plugin = { workspace = true, features = ["build"] }
 
 [dev-dependencies]
 specta-typescript = { workspace = true }
+tokio = { workspace = true, features = ["macros", "rt"] }
 
 hypr-docs = { workspace = true }
 
@@ -24,6 +25,8 @@ serde_json = { workspace = true }
 serde_yaml = { workspace = true }
 specta = { workspace = true }
 
+dirs = { workspace = true }
 futures-util = { workspace = true }
+shellexpand = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true, features = ["process"] }
diff --git a/plugins/hooks/js/bindings.gen.ts b/plugins/hooks/js/bindings.gen.ts
@@ -7,7 +7,7 @@
 
 
 export const commands = {
-async runEventHooks(event: HookEvent) : Promise<Result<null, string>> {
+async runEventHooks(event: HookEvent) : Promise<Result<HookResult[], string>> {
     try {
     return { status: "ok", data: await TAURI_INVOKE("plugin:hooks|run_event_hooks", { event }) };
 } catch (e) {
@@ -68,6 +68,7 @@ export type HookDefinition = {
  */
 command: string }
 export type HookEvent = { afterListeningStopped: { args: AfterListeningStoppedArgs } } | { beforeListeningStarted: { args: BeforeListeningStartedArgs } }
+export type HookResult = { command: string; success: boolean; exit_code: number | null; stdout: string; stderr: string }
 /**
  * Configuration for hook execution.
  */
diff --git a/plugins/hooks/src/commands.rs b/plugins/hooks/src/commands.rs
@@ -1,10 +1,10 @@
-use crate::{event::HookEvent, HooksPluginExt};
+use crate::{event::HookEvent, runner::HookResult, HooksPluginExt};
 
 #[tauri::command]
 #[specta::specta]
 pub(crate) async fn run_event_hooks<R: tauri::Runtime>(
     app: tauri::AppHandle<R>,
     event: HookEvent,
-) -> Result<(), String> {
-    app.run_hooks(event).map_err(|e| e.to_string())
+) -> Result<Vec<HookResult>, String> {
+    app.run_hooks(event).await.map_err(|e| e.to_string())
 }
diff --git a/plugins/hooks/src/config.rs b/plugins/hooks/src/config.rs
@@ -40,13 +40,11 @@ impl HooksConfig {
         Ok(config)
     }
 
-    fn config_path<R: tauri::Runtime>(app: &impl tauri::Manager<R>) -> crate::Result<PathBuf> {
-        let app_data_dir = app
-            .path()
-            .app_data_dir()
-            .map_err(|e| crate::Error::ConfigLoad(e.to_string()))?;
+    fn config_path<R: tauri::Runtime>(_app: &impl tauri::Manager<R>) -> crate::Result<PathBuf> {
+        let data_dir =
+            dirs::data_dir().ok_or_else(|| crate::Error::ConfigLoad("no data dir".to_string()))?;
 
-        Ok(app_data_dir.join("hyprnote").join("hooks.json"))
+        Ok(data_dir.join("hyprnote").join("hooks.json"))
     }
 
     fn empty() -> Self {
diff --git a/plugins/hooks/src/event.rs b/plugins/hooks/src/event.rs
@@ -3,8 +3,10 @@ use std::ffi::OsString;
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize, specta::Type)]
 pub enum HookEvent {
+    #[serde(rename = "afterListeningStopped")]
     #[specta(rename = "afterListeningStopped")]
     AfterListeningStopped { args: AfterListeningStoppedArgs },
+    #[serde(rename = "beforeListeningStarted")]
     #[specta(rename = "beforeListeningStarted")]
     BeforeListeningStarted { args: BeforeListeningStartedArgs },
 }
diff --git a/plugins/hooks/src/ext.rs b/plugins/hooks/src/ext.rs
@@ -1,15 +1,21 @@
-use crate::{event::HookEvent, runner::run_hooks_for_event};
+use crate::{
+    event::HookEvent,
+    runner::{run_hooks_for_event, HookResult},
+};
 
 pub trait HooksPluginExt<R: tauri::Runtime> {
-    fn run_hooks(&self, event: HookEvent) -> crate::Result<()>;
+    fn run_hooks(
+        &self,
+        event: HookEvent,
+    ) -> impl std::future::Future<Output = crate::Result<Vec<HookResult>>> + Send;
 }
 
 impl<R, T> HooksPluginExt<R> for T
 where
     R: tauri::Runtime,
-    T: tauri::Manager<R>,
+    T: tauri::Manager<R> + Send + Sync,
 {
-    fn run_hooks(&self, event: HookEvent) -> crate::Result<()> {
-        run_hooks_for_event(self, event)
+    async fn run_hooks(&self, event: HookEvent) -> crate::Result<Vec<HookResult>> {
+        run_hooks_for_event(self, event).await
     }
 }
diff --git a/plugins/hooks/src/lib.rs b/plugins/hooks/src/lib.rs
@@ -9,8 +9,9 @@ mod runner;
 #[cfg(test)]
 mod docs;
 
-pub use error::{Error, Result};
+pub use error::*;
 pub use ext::*;
+pub use runner::*;
 
 const PLUGIN_NAME: &str = "hooks";
 
diff --git a/plugins/hooks/src/runner.rs b/plugins/hooks/src/runner.rs
diff --git a/scripts/yabai.sh b/scripts/yabai.sh
diff --git a/scripts/yabai_impl.sh b/scripts/yabai_impl.sh
