Fix data directory path and add keepalive task

Dockerfile

@@ -43,8 +43,8 @@ COPY --chown=user --from=backend-builder /app/target/release/antigravity-server
 # Copy frontend static files
 COPY --chown=user --from=frontend-builder /app/dist ./static
 
-# Create data directory
-RUN mkdir -p /home/user/app/data
+# Create data directory with accounts subdirectory
+RUN mkdir -p /home/user/app/data/accounts
 
 # Expose port
 EXPOSE 7860

server/src/main.rs

@@ -18,12 +18,19 @@ async fn main() {
     info!("Starting Antigravity API Proxy Server...");
 
     // Get data directory
+    // Priority: /data (HF persistent) > ./data (current dir) > ~/.antigravity_tools (fallback)
     let data_dir = if PathBuf::from("/data").exists() {
         PathBuf::from("/data")
+    } else if PathBuf::from("./data").exists() {
+        PathBuf::from("./data").canonicalize().unwrap_or_else(|_| PathBuf::from("./data"))
     } else {
-        dirs::home_dir()
+        let home_dir = dirs::home_dir()
             .expect("Cannot get home directory")
-            .join(".antigravity_tools")
+            .join(".antigravity_tools");
+        // Create the directory if it doesn't exist
+        let _ = std::fs::create_dir_all(&home_dir);
+        let _ = std::fs::create_dir_all(home_dir.join("accounts"));
+        home_dir
     };
 
     info!("Using data directory: {:?}", data_dir);
@@ -108,6 +115,12 @@ async fn main() {
     let addr = format!("0.0.0.0:{}", port);
     info!("Server listening on http://{}", addr);
 
+    // Start keep-alive background task to prevent HuggingFace Spaces from sleeping
+    let keepalive_port = port;
+    tokio::spawn(async move {
+        keepalive_task(keepalive_port).await;
+    });
+
     let listener = tokio::net::TcpListener::bind(&addr)
         .await
         .expect("Failed to bind address");
@@ -117,6 +130,54 @@ async fn main() {
         .expect("Server error");
 }
 
+/// Keep-alive background task
+/// Pings the health check endpoint every 5 minutes to prevent HuggingFace Spaces from sleeping
+async fn keepalive_task(port: u16) {
+    use tokio::time::{interval, Duration};
+
+    // Wait 30 seconds for server to start
+    tokio::time::sleep(Duration::from_secs(30)).await;
+
+    let client = reqwest::Client::new();
+    let url = format!("http://127.0.0.1:{}/healthz", port);
+
+    // Check if keepalive is enabled (default: enabled)
+    let enabled = std::env::var("KEEPALIVE_ENABLED")
+        .map(|v| v != "false" && v != "0")
+        .unwrap_or(true);
+
+    if !enabled {
+        info!("Keep-alive task disabled");
+        return;
+    }
+
+    // Get interval from env (default: 5 minutes)
+    let interval_secs = std::env::var("KEEPALIVE_INTERVAL")
+        .ok()
+        .and_then(|v| v.parse::<u64>().ok())
+        .unwrap_or(300); // 5 minutes
+
+    info!("Keep-alive task started (interval: {}s)", interval_secs);
+
+    let mut ticker = interval(Duration::from_secs(interval_secs));
+
+    loop {
+        ticker.tick().await;
+
+        match client.get(&url).send().await {
+            Ok(resp) if resp.status().is_success() => {
+                tracing::debug!("Keep-alive ping successful");
+            }
+            Ok(resp) => {
+                tracing::warn!("Keep-alive ping returned status: {}", resp.status());
+            }
+            Err(e) => {
+                tracing::warn!("Keep-alive ping failed: {}", e);
+            }
+        }
+    }
+}
+
 /// Health check handler
 async fn health_check() -> axum::Json<serde_json::Value> {
     axum::Json(serde_json::json!({