Fix Tauri 2 permissions + multiple UI/UX improvements

- Add capabilities/default.json with required Tauri 2 permissions
- Fix async command handlers (remove async from sync functions)
- Add dark mode support via prefers-color-scheme media query
- Sort chats by most recent message (not message count)
- Remove unused "Save Locally" button and handler
- Add default-run to fix cargo binary ambiguity
- Add debug logging to list_chats and check_full_disk_access
- Fix Taskfile dev:local to include desktop feature

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: ndbroadbent

Taskfile.yml

@@ -15,17 +15,17 @@ tasks:
   dev:local:
     desc: Start Tauri dev mode (uses localhost:5173 API)
     cmds:
-      - cargo tauri dev --features dev-server
+      - cargo tauri dev --features desktop,dev-server
 
   build:
     desc: Build for production (points to chattomap.com)
     cmds:
       - cargo tauri build
 
-  build:dev:
-    desc: Build release with dev server (for testing)
+  build:local:
+    desc: Build release with localhost API (for testing)
     cmds:
-      - cargo tauri build --features dev-server
+      - cargo tauri build --features desktop,dev-server
 
   # === Quality Checks (run before marking any task complete) ===
   ci:

src-tauri/Cargo.toml

@@ -7,6 +7,7 @@ license = "GPL-3.0"
 repository = "https://github.com/DocSpring/chat_to_map_desktop"
 edition = "2021"
 rust-version = "1.70"
+default-run = "chat-to-map-desktop"
 
 [build-dependencies]
 tauri-build = { version = "2", features = [] }

src-tauri/capabilities/default.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "../gen/schemas/desktop-schema.json",
+  "identifier": "default",
+  "description": "Default capabilities for ChatToMap Desktop",
+  "windows": ["main"],
+  "permissions": [
+    "core:default",
+    "core:event:default",
+    "core:event:allow-listen",
+    "core:event:allow-emit",
+    "shell:allow-open"
+  ]
+}

src-tauri/src/lib.rs

@@ -39,24 +39,44 @@ pub struct ChatInfo {
     pub message_count: usize,
 }
 
-/// Get message counts per chat using custom SQL
-fn get_message_counts(
+/// Chat statistics (message count and last message timestamp)
+struct ChatStats {
+    message_count: usize,
+    last_message_date: i64,
+}
+
+/// Get message counts and last message date per chat using custom SQL
+fn get_chat_stats(
     db: &rusqlite::Connection,
-) -> Result<HashMap<i32, usize>, imessage_database::error::table::TableError> {
-    let mut counts = HashMap::new();
+) -> Result<HashMap<i32, ChatStats>, imessage_database::error::table::TableError> {
+    let mut stats = HashMap::new();
 
-    let mut stmt =
-        db.prepare("SELECT chat_id, COUNT(*) as count FROM chat_message_join GROUP BY chat_id")?;
+    let mut stmt = db.prepare(
+        "SELECT cmj.chat_id, COUNT(*) as count, MAX(m.date) as last_date
+         FROM chat_message_join cmj
+         JOIN message m ON cmj.message_id = m.ROWID
+         GROUP BY cmj.chat_id",
+    )?;
 
     let rows = stmt.query_map([], |row| {
-        Ok((row.get::<_, i32>(0)?, row.get::<_, usize>(1)?))
+        Ok((
+            row.get::<_, i32>(0)?,
+            row.get::<_, usize>(1)?,
+            row.get::<_, i64>(2).unwrap_or(0),
+        ))
     })?;
 
-    for (chat_id, count) in rows.flatten() {
-        counts.insert(chat_id, count);
+    for (chat_id, count, last_date) in rows.flatten() {
+        stats.insert(
+            chat_id,
+            ChatStats {
+                message_count: count,
+                last_message_date: last_date,
+            },
+        );
     }
 
-    Ok(counts)
+    Ok(stats)
 }
 
 /// Resolve a display name for a chat, using contacts if available
@@ -96,61 +116,86 @@ pub fn resolve_chat_display_name(
 
 /// List available iMessage chats
 pub fn list_chats() -> Result<Vec<ChatInfo>, String> {
+    eprintln!("[list_chats] Starting...");
+
     // Get database path
     let db_path = default_db_path();
+    eprintln!("[list_chats] DB path: {:?}", db_path);
 
     // Connect to database
     let db = get_connection(&db_path).map_err(|e| format!("Failed to connect to database: {e}"))?;
+    eprintln!("[list_chats] Connected to database");
 
     // Build contacts index for name resolution
+    eprintln!("[list_chats] Building contacts index...");
     let contacts_index = ContactsIndex::build(None).unwrap_or_default();
+    eprintln!("[list_chats] Contacts index built");
 
     // Cache all chats
+    eprintln!("[list_chats] Loading chats...");
     let chats = Chat::cache(&db).map_err(|e| format!("Failed to load chats: {e}"))?;
+    eprintln!("[list_chats] Loaded {} chats", chats.len());
 
     // Cache handles (contacts)
+    eprintln!("[list_chats] Loading handles...");
     let handles = Handle::cache(&db).map_err(|e| format!("Failed to load handles: {e}"))?;
     let deduped_handles = Handle::dedupe(&handles);
+    eprintln!("[list_chats] Loaded {} handles", handles.len());
 
     // Build participants map with resolved names
     let participants_map = contacts_index.build_participants_map(&handles, &deduped_handles);
 
     // Cache chat participants (chat_id -> set of handle_ids)
+    eprintln!("[list_chats] Loading chat participants...");
     let chat_participants =
         ChatToHandle::cache(&db).map_err(|e| format!("Failed to load participants: {e}"))?;
-
-    // Get message counts
-    let message_counts =
-        get_message_counts(&db).map_err(|e| format!("Failed to get message counts: {e}"))?;
-
-    // Build result
-    let mut result: Vec<ChatInfo> = chats
+    eprintln!(
+        "[list_chats] Loaded participants for {} chats",
+        chat_participants.len()
+    );
+
+    // Get chat stats (message counts and last message dates)
+    eprintln!("[list_chats] Getting chat stats...");
+    let chat_stats = get_chat_stats(&db).map_err(|e| format!("Failed to get chat stats: {e}"))?;
+    eprintln!("[list_chats] Got chat stats");
+
+    // Build result with last_message_date for sorting
+    let mut result: Vec<(ChatInfo, i64)> = chats
         .into_iter()
         .map(|(id, chat)| {
             let participants = chat_participants.get(&id);
             let participant_count = participants.map(|p| p.len()).unwrap_or(0);
-            let message_count = message_counts.get(&id).copied().unwrap_or(0);
+            let stats = chat_stats.get(&id);
+            let message_count = stats.map(|s| s.message_count).unwrap_or(0);
+            let last_message_date = stats.map(|s| s.last_message_date).unwrap_or(0);
 
             let display_name =
                 resolve_chat_display_name(&chat, participants, &participants_map, &deduped_handles);
 
-            ChatInfo {
-                id,
-                display_name,
-                chat_identifier: chat.chat_identifier.clone(),
-                service: chat
-                    .service_name
-                    .as_deref()
-                    .unwrap_or("Unknown")
-                    .to_string(),
-                participant_count,
-                message_count,
-            }
+            (
+                ChatInfo {
+                    id,
+                    display_name,
+                    chat_identifier: chat.chat_identifier.clone(),
+                    service: chat
+                        .service_name
+                        .as_deref()
+                        .unwrap_or("Unknown")
+                        .to_string(),
+                    participant_count,
+                    message_count,
+                },
+                last_message_date,
+            )
         })
         .collect();
 
-    // Sort by message count descending (most active chats first)
-    result.sort_by(|a, b| b.message_count.cmp(&a.message_count));
+    // Sort by last message date descending (most recent first)
+    result.sort_by(|a, b| b.1.cmp(&a.1));
+
+    // Extract just the ChatInfo
+    let result: Vec<ChatInfo> = result.into_iter().map(|(info, _)| info).collect();
 
+    eprintln!("[list_chats] Done! Returning {} chats", result.len());
     Ok(result)
 }

src-tauri/src/main.rs

@@ -22,8 +22,14 @@ pub struct ExportResult {
 
 /// List available iMessage chats
 #[tauri::command]
-async fn list_chats() -> Result<Vec<ChatInfo>, String> {
-    lib_list_chats()
+fn list_chats() -> Result<Vec<ChatInfo>, String> {
+    eprintln!("[tauri::list_chats] Command invoked");
+    let result = lib_list_chats();
+    eprintln!(
+        "[tauri::list_chats] Result: {:?}",
+        result.as_ref().map(|v| v.len())
+    );
+    result
 }
 
 /// Export selected chats and upload to server
@@ -129,19 +135,28 @@ async fn export_and_upload(
 
 /// Check if Full Disk Access is granted (macOS)
 #[tauri::command]
-async fn check_full_disk_access() -> Result<bool, String> {
+fn check_full_disk_access() -> Result<bool, String> {
+    eprintln!("[check_full_disk_access] Checking...");
     #[cfg(target_os = "macos")]
     {
         // Check if we can actually read the database
         let db_path = default_db_path();
+        eprintln!("[check_full_disk_access] DB path: {:?}", db_path);
         if !db_path.exists() {
+            eprintln!("[check_full_disk_access] DB does not exist");
             return Ok(false);
         }
 
         // Try to open the database - this will fail without FDA
         match get_connection(&db_path) {
-            Ok(_) => Ok(true),
-            Err(_) => Ok(false),
+            Ok(_) => {
+                eprintln!("[check_full_disk_access] FDA granted (can open DB)");
+                Ok(true)
+            }
+            Err(e) => {
+                eprintln!("[check_full_disk_access] FDA denied: {:?}", e);
+                Ok(false)
+            }
         }
     }
 
@@ -153,7 +168,7 @@ async fn check_full_disk_access() -> Result<bool, String> {
 
 /// Open System Preferences to Full Disk Access (macOS)
 #[tauri::command]
-async fn open_full_disk_access_settings() -> Result<(), String> {
+fn open_full_disk_access_settings() -> Result<(), String> {
     #[cfg(target_os = "macos")]
     {
         std::process::Command::new("open")
@@ -164,21 +179,6 @@ async fn open_full_disk_access_settings() -> Result<(), String> {
     Ok(())
 }
 
-/// Save export locally (fallback when upload fails)
-#[tauri::command]
-async fn save_export_locally(chat_ids: Vec<i32>, save_path: String) -> Result<String, String> {
-    let export_result = tokio::task::spawn_blocking(move || export_chats(&chat_ids, None))
-        .await
-        .map_err(|e| format!("Export task failed: {e}"))?
-        .map_err(|e| format!("Export failed: {e}"))?;
-
-    // Copy zip to user-specified location
-    std::fs::copy(&export_result.zip_path, &save_path)
-        .map_err(|e| format!("Failed to save file: {e}"))?;
-
-    Ok(save_path)
-}
-
 fn main() {
     tauri::Builder::default()
         .plugin(tauri_plugin_shell::init())
@@ -187,7 +187,6 @@ fn main() {
             export_and_upload,
             check_full_disk_access,
             open_full_disk_access_settings,
-            save_export_locally,
         ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");

src/index.html

@@ -88,12 +88,7 @@ <h2>Export Complete!</h2>
           <div class="icon">⚠️</div>
           <h2>Something went wrong</h2>
           <p id="error-message"></p>
-          <div class="error-actions">
-            <button id="retry-btn" class="btn btn-primary">Try Again</button>
-            <button id="save-locally-btn" class="btn btn-secondary">
-              Save Locally
-            </button>
-          </div>
+          <button id="retry-btn" class="btn btn-primary">Try Again</button>
         </div>
       </main>
 

src/main.ts

@@ -68,8 +68,7 @@ const elements = {
   openResultsBtn: getElement<HTMLButtonElement>('open-results-btn'),
 
   errorMessage: getElement<HTMLElement>('error-message'),
-  retryBtn: getElement<HTMLButtonElement>('retry-btn'),
-  saveLocallyBtn: getElement<HTMLButtonElement>('save-locally-btn')
+  retryBtn: getElement<HTMLButtonElement>('retry-btn')
 }
 
 // Screen management
@@ -196,12 +195,14 @@ function setupEventListeners(): void {
 
   // Error screen
   elements.retryBtn.addEventListener('click', handleExport)
-  elements.saveLocallyBtn.addEventListener('click', handleSaveLocally)
 }
 
 async function checkPermissionAndLoadChats(): Promise<void> {
+  console.log('[checkPermissionAndLoadChats] Starting...')
   try {
+    console.log('[checkPermissionAndLoadChats] Invoking check_full_disk_access...')
     const hasAccess = await invoke<boolean>('check_full_disk_access')
+    console.log('[checkPermissionAndLoadChats] hasAccess:', hasAccess)
 
     if (!hasAccess) {
       showScreen(elements.permissionScreen)
@@ -254,11 +255,6 @@ async function handleExport(): Promise<void> {
   }
 }
 
-function handleSaveLocally(): void {
-  // TODO: Implement save to local file
-  alert('Save locally feature coming soon')
-}
-
 function showError(message: string): void {
   elements.errorMessage.textContent = message
   showScreen(elements.errorScreen)

src/styles.css

@@ -10,10 +10,28 @@
   --color-text: #111827;
   --color-text-secondary: #6b7280;
   --color-border: #e5e7eb;
+  --color-selected: #eff6ff;
   --radius: 8px;
   --shadow: 0 1px 3px 0 rgb(0 0 0 / 0.1);
 }
 
+@media (prefers-color-scheme: dark) {
+  :root {
+    --color-primary: #3b82f6;
+    --color-primary-hover: #2563eb;
+    --color-secondary: #9ca3af;
+    --color-secondary-hover: #6b7280;
+    --color-success: #34d399;
+    --color-error: #f87171;
+    --color-bg: #1f2937;
+    --color-bg-secondary: #111827;
+    --color-text: #f9fafb;
+    --color-text-secondary: #9ca3af;
+    --color-border: #374151;
+    --color-selected: #1e3a5f;
+  }
+}
+
 * {
   box-sizing: border-box;
   margin: 0;