Add permission step to onboarding

Author: anchpop

src-tauri/src/commands/mod.rs

@@ -130,3 +130,34 @@ pub fn check_apple_intelligence_available() -> bool {
         false
     }
 }
+
+/// Try to initialize Enigo (keyboard/mouse simulation).
+/// On macOS, this will return an error if accessibility permissions are not granted.
+#[specta::specta]
+#[tauri::command]
+pub fn initialize_enigo(app: AppHandle) -> Result<(), String> {
+    use crate::input::EnigoState;
+
+    // Check if already initialized
+    if app.try_state::<EnigoState>().is_some() {
+        log::info!("Enigo already initialized");
+        return Ok(());
+    }
+
+    // Try to initialize
+    match EnigoState::new() {
+        Ok(enigo_state) => {
+            app.manage(enigo_state);
+            log::info!("Enigo initialized successfully after permission grant");
+            Ok(())
+        }
+        Err(e) => {
+            if cfg!(target_os = "macos") {
+                log::warn!("Failed to initialize Enigo: {} (accessibility permissions may not be granted)", e);
+            } else {
+                log::warn!("Failed to initialize Enigo: {}", e);
+            }
+            Err(format!("Failed to initialize input system: {}", e))
+        }
+    }
+}

src-tauri/src/lib.rs

@@ -110,9 +110,10 @@ fn show_main_window(app: &AppHandle) {
 }
 
 fn initialize_core_logic(app_handle: &AppHandle) {
-    // Initialize the input state (Enigo singleton for keyboard/mouse simulation)
-    let enigo_state = input::EnigoState::new().expect("Failed to initialize input state (Enigo)");
-    app_handle.manage(enigo_state);
+    // Note: Enigo (keyboard/mouse simulation) is NOT initialized here.
+    // The frontend is responsible for calling the `initialize_enigo` command
+    // after onboarding completes. This avoids triggering permission dialogs
+    // on macOS before the user is ready.
 
     // Initialize the managers
     let recording_manager = Arc::new(
@@ -275,6 +276,7 @@ pub fn run() {
         commands::open_log_dir,
         commands::open_app_data_dir,
         commands::check_apple_intelligence_available,
+        commands::initialize_enigo,
         commands::models::get_available_models,
         commands::models::get_model_info,
         commands::models::download_model,

src/App.tsx

@@ -1,29 +1,53 @@
-import { useEffect, useState } from "react";
+import { useEffect, useState, useRef } from "react";
 import { Toaster } from "sonner";
 import "./App.css";
 import AccessibilityPermissions from "./components/AccessibilityPermissions";
 import Footer from "./components/footer";
-import Onboarding from "./components/onboarding";
+import Onboarding, { AccessibilityOnboarding } from "./components/onboarding";
 import { Sidebar, SidebarSection, SECTIONS_CONFIG } from "./components/Sidebar";
 import { useSettings } from "./hooks/useSettings";
+import { useSettingsStore } from "./stores/settingsStore";
 import { commands } from "@/bindings";
 
+type OnboardingStep = "accessibility" | "model" | "done";
+
 const renderSettingsContent = (section: SidebarSection) => {
   const ActiveComponent =
     SECTIONS_CONFIG[section]?.component || SECTIONS_CONFIG.general.component;
   return <ActiveComponent />;
 };
 
 function App() {
-  const [showOnboarding, setShowOnboarding] = useState<boolean | null>(null);
+  const [onboardingStep, setOnboardingStep] = useState<OnboardingStep | null>(
+    null
+  );
   const [currentSection, setCurrentSection] =
     useState<SidebarSection>("general");
   const { settings, updateSetting } = useSettings();
+  const refreshAudioDevices = useSettingsStore(
+    (state) => state.refreshAudioDevices
+  );
+  const refreshOutputDevices = useSettingsStore(
+    (state) => state.refreshOutputDevices
+  );
+  const hasCompletedPostOnboardingInit = useRef(false);
 
   useEffect(() => {
     checkOnboardingStatus();
   }, []);
 
+  // Initialize Enigo and refresh audio devices when main app loads
+  useEffect(() => {
+    if (onboardingStep === "done" && !hasCompletedPostOnboardingInit.current) {
+      hasCompletedPostOnboardingInit.current = true;
+      commands.initializeEnigo().catch((e) => {
+        console.warn("Failed to initialize Enigo:", e);
+      });
+      refreshAudioDevices();
+      refreshOutputDevices();
+    }
+  }, [onboardingStep, refreshAudioDevices, refreshOutputDevices]);
+
   // Handle keyboard shortcuts for debug mode toggle
   useEffect(() => {
     const handleKeyDown = (event: KeyboardEvent) => {
@@ -51,25 +75,39 @@ function App() {
 
   const checkOnboardingStatus = async () => {
     try {
-      // Always check if they have any models available
+      // Check if they have any models available
       const result = await commands.hasAnyModelsAvailable();
       if (result.status === "ok") {
-        setShowOnboarding(!result.data);
+        // If they have models/downloads, they're done. Otherwise start permissions step.
+        setOnboardingStep(result.data ? "done" : "accessibility");
       } else {
-        setShowOnboarding(true);
+        setOnboardingStep("accessibility");
       }
     } catch (error) {
       console.error("Failed to check onboarding status:", error);
-      setShowOnboarding(true);
+      setOnboardingStep("accessibility");
     }
   };
 
+  const handleAccessibilityComplete = () => {
+    setOnboardingStep("model");
+  };
+
   const handleModelSelected = () => {
     // Transition to main app - user has started a download
-    setShowOnboarding(false);
+    setOnboardingStep("done");
   };
 
-  if (showOnboarding) {
+  // Still checking onboarding status
+  if (onboardingStep === null) {
+    return null;
+  }
+
+  if (onboardingStep === "accessibility") {
+    return <AccessibilityOnboarding onComplete={handleAccessibilityComplete} />;
+  }
+
+  if (onboardingStep === "model") {
     return <Onboarding onModelSelected={handleModelSelected} />;
   }
 

src/bindings.ts

@@ -350,6 +350,18 @@ async openAppDataDir() : Promise<Result<null, string>> {
 async checkAppleIntelligenceAvailable() : Promise<boolean> {
     return await TAURI_INVOKE("check_apple_intelligence_available");
 },
+/**
+ * Try to initialize Enigo (keyboard/mouse simulation).
+ * On macOS, this will return an error if accessibility permissions are not granted.
+ */
+async initializeEnigo() : Promise<Result<null, string>> {
+    try {
+    return { status: "ok", data: await TAURI_INVOKE("initialize_enigo") };
+} catch (e) {
+    if(e instanceof Error) throw e;
+    else return { status: "error", error: e  as any };
+}
+},
 async getAvailableModels() : Promise<Result<ModelInfo[], string>> {
     try {
     return { status: "ok", data: await TAURI_INVOKE("get_available_models") };