fix: handle temp file removal race condition in concurrent initialization

When multiple SQLPage instances start simultaneously in the same directory,
they can encounter a race condition during initialization. The create_default_database()
function creates a temporary file to test directory writability, then removes it.
If multiple instances try to remove the same file concurrently, some panic with
'No such file or directory'.

This commit replaces the .expect() panic with graceful error handling using
if let Err(). The writability test has already succeeded by the time we try
to remove the file, so whether another instance removed it is irrelevant.

Includes a test that spawns 10 concurrent threads initializing AppConfig
to verify no panics occur.

ref #1183

Author: mukhtaronif

src/app_config.rs

@@ -495,7 +495,11 @@ fn create_default_database(configuration_directory: &Path) -> String {
                 default_db_path.display()
             );
             drop(tmp_file);
-            std::fs::remove_file(&default_db_path).expect("removing temp file");
+            // Gracefully handle removal - file might already be removed by another instance
+            // in concurrent startup scenarios. 
+            if let Err(e) = std::fs::remove_file(&default_db_path) {
+                log::debug!("Temp file already removed or not found: {}", e);
+            }
             return prefix + &encode_uri(&default_db_path) + "?mode=rwc";
         }
     }
@@ -798,4 +802,44 @@ mod test {
             "Configuration directory should default to ./sqlpage when not specified"
         );
     }
+
+    #[test]
+    fn test_concurrent_initialization_no_panic() {
+        let _lock = ENV_LOCK
+            .lock()
+            .expect("Another test panicked while holding the lock");
+
+        let test_dir = std::env::temp_dir().join(format!(
+            "sqlpage_race_test_{}",
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_nanos()
+        ));
+        std::fs::create_dir_all(&test_dir).unwrap();
+
+        env::remove_var("DATABASE_URL");
+
+        let handles: Vec<_> = (0..10)
+            .map(|_| {
+                let test_dir_clone = test_dir.clone();
+                std::thread::spawn(move || {
+                    let cli = Cli {
+                        web_root: None,
+                        config_dir: Some(test_dir_clone),
+                        config_file: None,
+                        command: None,
+                    };
+                    let result = AppConfig::from_cli(&cli);
+                    assert!(result.is_ok(), "AppConfig initialization should succeed");
+                })
+            })
+            .collect();
+
+        for handle in handles {
+            handle.join().expect("Thread should not panic");
+        }
+
+        let _ = std::fs::remove_dir_all(&test_dir);
+    }
 }