Add permission step to onboarding

Author: anchpop

src-tauri/src/commands/mod.rs

@@ -130,3 +130,30 @@ pub fn check_apple_intelligence_available() -> bool {
         false
     }
 }
+
+/// Try to initialize Enigo (keyboard/mouse simulation) after accessibility permissions are granted.
+/// This allows the app to gain paste functionality without requiring a restart.
+#[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) => {
+            log::warn!("Failed to initialize Enigo: {}", e);
+            Err(format!("Failed to initialize input system: {}", e))
+        }
+    }
+}

src-tauri/src/lib.rs

@@ -111,8 +111,24 @@ 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);
+    // On macOS, we skip this at startup to avoid triggering the permission dialog.
+    // The frontend will call initialize_enigo after the user grants permission.
+    // On other platforms, we initialize immediately since no permission is needed.
+    #[cfg(not(target_os = "macos"))]
+    {
+        match input::EnigoState::new() {
+            Ok(enigo_state) => {
+                app_handle.manage(enigo_state);
+            }
+            Err(e) => {
+                log::warn!(
+                    "Failed to initialize input state (Enigo): {}. \
+                     Paste functionality may be unavailable.",
+                    e
+                );
+            }
+        }
+    }
 
     // Initialize the managers
     let recording_manager = Arc::new(
@@ -275,6 +291,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

@@ -3,19 +3,23 @@ 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 { 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();
@@ -51,25 +55,39 @@ function App() {
 
   const checkOnboardingStatus = async () => {
     try {
-      // Always check if they have any models available
-      const result = await commands.hasAnyModelsAvailable();
+      // Check if they have any models or are using cloud transcription
+      const result = await commands.hasAnyModelsOrDownloads();
       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) after accessibility permissions are granted.
+ * This allows the app to gain paste functionality without requiring a restart.
+ */
+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") };