Implement simplified session manager with persistence

- New SimpleSessionManager: thread-safe in-memory with filesystem persistence
- JSON index for session metadata and alias mapping
- Automatic cleanup of idle sessions (>6 hours)
- Human-readable session aliases
- Much simpler and more maintainable than previous complex system
- Updated app.py to use new manager

app.py

@@ -1,8 +1,8 @@
 """
-Quantum Applications - Unified Single-Server App with Multi-User Session Management
+Quantum Applications - Unified Single-Server App with Simplified Session Management
 
 This app provides EM scattering and QLBM pages in a single Trame server
-with support for multiple concurrent users and session persistence.
+with simplified session management based on filesystem directories and persistent indices.
 """
 import os
 import errno
@@ -17,30 +17,12 @@ import threading
 import time
 import base64
 
-from session_integration import SessionIntegration
-from landing_page import build_landing_page_ui
+from simple_session_manager import SESSION_MANAGER, get_session_by_alias
 
 # Create a single server for the entire app
 server = get_server()
 state, ctrl = server.state, server.controller
 
-# --- User & Session Management ---
-# Generate or retrieve user ID (in production, use HF auth)
-def _get_or_create_user_id():
-    """Get user ID from HF auth or create a session-specific one."""
-    import secrets
-    
-    # Try to get HF username from environment (when using HF launcher)
-    hf_user = os.environ.get("HF_USER")
-    if hf_user:
-        return hf_user
-    
-    # Fallback: create a unique ID per session
-    return secrets.token_hex(8)
-
-user_id = _get_or_create_user_id()
-session_integration = SessionIntegration(user_id)
-
 # --- App state
 state.current_page = None  # None = landing, "EM" or "QLBM"
 state.session_active = False
@@ -89,43 +71,29 @@ em.init_state()
 em.register_handlers()
 
 # --- Session Callbacks ---
-def on_session_selected(session_id: str, app_type: str):
+def on_session_selected(session_id: str):
     """Callback when user selects a session from landing page."""
     try:
-        metadata, session_state = session_integration.load_session(session_id)
+        session_info = SESSION_MANAGER.get_session(session_id=session_id)
+        if not session_info:
+            state.session_error = f"Session not found: {session_id}"
+            return
+        
         state.current_session_id = session_id
-        state.session_alias = metadata.alias
+        state.session_alias = session_info.get("alias", "Untitled")
         state.session_active = True
-        
-        # Restore app state from session
-        session_integration.restore_to_trame_state(state)
-        
-        print(f"Session loaded: {metadata.alias} ({app_type})")
+        print(f"[APP] Session selected: {state.session_alias} ({session_id})")
     except Exception as e:
-        print(f"Error loading session: {e}")
+        print(f"[APP] Error selecting session: {e}")
+        state.session_error = str(e)
         state.session_active = False
 
-def on_app_selected(app_type: str):
-    """Callback when user selects an app after session."""
-    state.current_page = app_type
-
-
 # --- Controller to reset UI on page load ---
 @ctrl.add("reset_ui")
 def _reset_ui():
-    """Reset UI to landing page (called when browser loads the page or new browser session detected)."""
-    print(f"[RESET_UI] Called. Current state before reset:")
-    print(f"  current_page={state.current_page}, session_active={state.session_active}")
+    """Reset UI to landing page (called when browser closes/reopens)."""
+    print(f"[RESET_UI] Resetting to landing page")
     
-    # Save current session before resetting if one is active
-    if state.session_active and session_integration.current_session_id:
-        try:
-            session_integration.save_current_session(state)
-            print(f"[RESET_UI] Session saved: {state.session_alias}")
-        except Exception as e:
-            print(f"[RESET_UI WARN] Could not save session: {e}")
-    
-    # Reset all UI and session state to landing page
     state.current_page = None
     state.session_card_visible = True
     state.session_active = False
@@ -134,13 +102,6 @@ def _reset_ui():
     state.session_alias_input = ""
     state.session_error = ""
     state.session_action_trigger = None
-    
-    # Clear session integration
-    session_integration.current_session_id = None
-    session_integration.current_metadata = None
-    session_integration.current_state = None
-    
-    print(f"[RESET_UI] State reset. New state: current_page={state.current_page}")
 
 
 @ctrl.add("on_page_load")
@@ -150,21 +111,17 @@ def _on_page_load(is_new_session: bool):
     if is_new_session:
         print(f"[PAGE_LOAD] New session detected. Resetting to landing page.")
         _reset_ui()
-    else:
-        print(f"[PAGE_LOAD] Page refresh detected. Keeping current state.")
-        print(f"[PAGE_LOAD] Current state: current_page={state.current_page}, session_active={state.session_active}")
 
 
 # Watcher to reset navigation when no session is active
-# (handles case where user closes browser and comes back)
 @state.change("session_active")
 def _on_session_status_change(session_active, **kwargs):
     """Reset landing page if session becomes inactive."""
     if not session_active and state.current_page is not None:
-        # Session became inactive; reset to landing page
         state.current_page = None
         state.session_card_visible = True
-        print("[OK] Session inactive; reset to landing page")
+        print("[APP] Session inactive; reset to landing page")
+
 
 # --- Session action watchers (respond to state changes from UI) ---
 @state.change("session_action_trigger")
@@ -174,32 +131,34 @@ def _on_session_action(session_action_trigger, **kwargs):
         try:
             state.session_action_busy = True
             alias = state.session_alias_input.strip() if state.session_alias_input else f"session-{uuid.uuid4().hex[:6]}"
-            session_id, metadata = session_integration.create_new_session(alias, app_type="MULTI")
-            state.session_alias = metadata.alias
+            
+            # Create new session
+            session_info = SESSION_MANAGER.create_session(alias=alias)
+            session_id = session_info["session_id"]
+            
+            state.session_alias = session_info.get("alias", "Untitled")
             state.session_active = True
             state.current_session_id = session_id
-            state.current_page = None  # ALWAYS reset to landing page
-            state.session_alias_input = ""  # Clear input field after success
+            state.current_page = None
+            state.session_alias_input = ""
             state.session_action_success = True
             state.session_error = ""
-            print(f"[OK] Session created: {alias}")
+            print(f"[APP] Session created: {alias} ({session_id})")
             
-            # Schedule card to hide and success icon to disappear
+            # Hide card after success animation
             def _hide():
-                time.sleep(1.5)  # Show success animation for 1.5 sec
+                time.sleep(1.5)
                 state.session_card_visible = False
                 state.session_action_success = False
                 state.session_action_busy = False
                 state.session_action_trigger = None
-                print("[OK] Card hidden")
             
             threading.Thread(target=_hide, daemon=True).start()
-            return True
         except Exception as e:
             state.session_error = str(e)
             state.session_action_busy = False
             state.session_action_trigger = None
-            print(f"[ERROR] Session create error: {e}")
+            print(f"[APP] Error creating session: {e}")
 
     elif session_action_trigger == "load":
         try:
@@ -211,38 +170,37 @@ def _on_session_action(session_action_trigger, **kwargs):
                 state.session_action_trigger = None
                 return
 
-            result = session_integration.load_by_alias(alias)
-            if not result:
+            # Load session by alias
+            session_info = get_session_by_alias(alias)
+            if not session_info:
                 state.session_error = f"No session found with alias '{alias}'."
                 state.session_action_busy = False
                 state.session_action_trigger = None
                 return
 
-            metadata, session_state = result
-            state.session_alias = metadata.alias
+            session_id = session_info["session_id"]
+            state.session_alias = session_info.get("alias", "Untitled")
             state.session_active = True
-            state.current_session_id = session_state.session_id
-            state.current_page = None  # ALWAYS reset to landing page
-            state.session_alias_input = ""  # Clear input field after success
-            session_integration.restore_to_trame_state(state)
+            state.current_session_id = session_id
+            state.current_page = None
+            state.session_alias_input = ""
             state.session_action_success = True
             state.session_error = ""
-            print(f"[OK] Session loaded: {alias}")
+            print(f"[APP] Session loaded: {alias} ({session_id})")
 
             def _hide_load():
-                time.sleep(1.5)  # Show success animation for 1.5 sec
+                time.sleep(1.5)
                 state.session_card_visible = False
                 state.session_action_success = False
                 state.session_action_busy = False
                 state.session_action_trigger = None
 
             threading.Thread(target=_hide_load, daemon=True).start()
-            return True
         except Exception as e:
             state.session_error = str(e)
             state.session_action_busy = False
             state.session_action_trigger = None
-            print(f"[ERROR] Session load error: {e}")
+            print(f"[APP] Error loading session: {e}")
 
 
 # --- Build the Layout ---

simple_session_manager.py

@@ -0,0 +1,270 @@
+"""
+Simplified Session Manager (inspired by Udbhav's approach)
+
+Features:
+- In-memory session tracking with thread-safe RLock
+- Simple filesystem-based storage (one directory per session)
+- Persistent session index (JSON) and alias map
+- Automatic cleanup of idle sessions (>6 hours)
+- Human-readable aliases for sessions
+"""
+
+import os
+import json
+import shutil
+import threading
+import uuid
+import time
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Dict, Optional
+
+# Base directory for all sessions (HF persistent storage)
+BASE_DATA_DIR = Path("/tmp/outputs/sessions")
+
+# Session index file (persisted to disk)
+SESSIONS_INDEX_FILE = BASE_DATA_DIR / "sessions_index.json"
+
+# Alias map file (maps friendly names to session IDs)
+ALIAS_MAP_FILE = BASE_DATA_DIR / "alias_map.json"
+
+
+class SimpleSessionManager:
+    """
+    Thread-safe session manager with persistence and auto-cleanup.
+    """
+    
+    def __init__(self):
+        self.sessions: Dict[str, dict] = {}
+        self.alias_map: Dict[str, str] = {}  # alias -> session_id
+        self._lock = threading.RLock()
+        self._cleanup_thread = None
+        
+        # Ensure directories exist
+        BASE_DATA_DIR.mkdir(parents=True, exist_ok=True)
+        print(f"[SESSION] Base directory: {BASE_DATA_DIR}")
+        
+        # Load persisted data
+        self._load_index()
+        self._load_alias_map()
+        
+        # Start cleanup thread
+        self._start_cleanup_thread()
+    
+    def _load_index(self):
+        """Load sessions index from disk."""
+        if SESSIONS_INDEX_FILE.exists():
+            try:
+                with open(SESSIONS_INDEX_FILE, 'r') as f:
+                    data = json.load(f)
+                    self.sessions = data
+                    print(f"[SESSION] Loaded {len(self.sessions)} sessions from index")
+            except Exception as e:
+                print(f"[SESSION] Error loading index: {e}")
+    
+    def _load_alias_map(self):
+        """Load alias map from disk."""
+        if ALIAS_MAP_FILE.exists():
+            try:
+                with open(ALIAS_MAP_FILE, 'r') as f:
+                    self.alias_map = json.load(f)
+                    print(f"[SESSION] Loaded {len(self.alias_map)} aliases")
+            except Exception as e:
+                print(f"[SESSION] Error loading alias map: {e}")
+    
+    def _save_index(self):
+        """Save sessions index to disk."""
+        try:
+            SESSIONS_INDEX_FILE.parent.mkdir(parents=True, exist_ok=True)
+            with open(SESSIONS_INDEX_FILE, 'w') as f:
+                json.dump(self.sessions, f, indent=2, default=str)
+        except Exception as e:
+            print(f"[SESSION] Error saving index: {e}")
+    
+    def _save_alias_map(self):
+        """Save alias map to disk."""
+        try:
+            ALIAS_MAP_FILE.parent.mkdir(parents=True, exist_ok=True)
+            with open(ALIAS_MAP_FILE, 'w') as f:
+                json.dump(self.alias_map, f, indent=2)
+        except Exception as e:
+            print(f"[SESSION] Error saving alias map: {e}")
+    
+    def _new_session(self, session_id: Optional[str] = None, alias: Optional[str] = None) -> Dict:
+        """Create a new session directory structure."""
+        if session_id is None:
+            session_id = str(uuid.uuid4())
+        
+        session_root = BASE_DATA_DIR / f"user_{session_id}"
+        
+        # Create subdirectories
+        subdirs = {
+            "data": session_root / "data",
+            "cache": session_root / "cache",
+            "results": session_root / "results",
+        }
+        
+        for dir_path in subdirs.values():
+            dir_path.mkdir(parents=True, exist_ok=True)
+        
+        session_info = {
+            "session_id": session_id,
+            "root": str(session_root),
+            "subdirs": {k: str(v) for k, v in subdirs.items()},
+            "created_at": datetime.now().isoformat(),
+            "last_accessed": datetime.now().isoformat(),
+            "alias": alias,
+        }
+        
+        print(f"[SESSION] Created new session: {session_id} (alias: {alias})")
+        return session_info
+    
+    def create_session(self, alias: Optional[str] = None) -> Dict:
+        """
+        Create a new session with optional alias.
+        
+        Args:
+            alias: Human-readable name for the session
+            
+        Returns:
+            Session info dict
+        """
+        with self._lock:
+            # If alias exists, return existing session
+            if alias and alias in self.alias_map:
+                session_id = self.alias_map[alias]
+                if session_id in self.sessions:
+                    print(f"[SESSION] Session '{alias}' already exists: {session_id}")
+                    self.sessions[session_id]["last_accessed"] = datetime.now().isoformat()
+                    self._save_index()
+                    return self.sessions[session_id]
+            
+            # Create new session
+            session_id = str(uuid.uuid4())
+            session_info = self._new_session(session_id, alias)
+            
+            self.sessions[session_id] = session_info
+            
+            if alias:
+                self.alias_map[alias] = session_id
+                self._save_alias_map()
+            
+            self._save_index()
+            return session_info
+    
+    def get_session(self, session_id: Optional[str] = None, alias: Optional[str] = None) -> Optional[Dict]:
+        """
+        Get session by ID or alias.
+        
+        Args:
+            session_id: Session UUID
+            alias: Human-readable session name
+            
+        Returns:
+            Session info dict or None
+        """
+        with self._lock:
+            # Lookup by alias first
+            if alias:
+                session_id = self.alias_map.get(alias)
+            
+            if not session_id:
+                return None
+            
+            session_info = self.sessions.get(session_id)
+            if session_info:
+                session_info["last_accessed"] = datetime.now().isoformat()
+                self._save_index()
+            
+            return session_info
+    
+    def list_sessions(self) -> Dict[str, Dict]:
+        """List all active sessions."""
+        with self._lock:
+            return {alias: self.sessions[sid] for alias, sid in self.alias_map.items() if sid in self.sessions}
+    
+    def delete_session(self, session_id: str) -> bool:
+        """Delete a session and its files."""
+        with self._lock:
+            session_info = self.sessions.pop(session_id, None)
+            if not session_info:
+                return False
+            
+            # Remove alias mapping
+            for alias, sid in list(self.alias_map.items()):
+                if sid == session_id:
+                    self.alias_map.pop(alias)
+            
+            # Remove directory
+            session_root = Path(session_info["root"])
+            try:
+                if session_root.exists():
+                    shutil.rmtree(session_root)
+                    print(f"[SESSION] Deleted session directory: {session_root}")
+            except Exception as e:
+                print(f"[SESSION] Error deleting {session_root}: {e}")
+            
+            self._save_index()
+            self._save_alias_map()
+            return True
+    
+    def _cleanup_old(self, max_age_hours: int = 6):
+        """Remove sessions idle longer than max_age_hours."""
+        now = datetime.now()
+        to_remove = []
+        
+        with self._lock:
+            for session_id, session_info in self.sessions.items():
+                last_accessed = datetime.fromisoformat(session_info["last_accessed"])
+                if now - last_accessed > timedelta(hours=max_age_hours):
+                    to_remove.append(session_id)
+        
+        for session_id in to_remove:
+            print(f"[SESSION] Cleaning up idle session: {session_id}")
+            self.delete_session(session_id)
+    
+    def _start_cleanup_thread(self):
+        """Start background cleanup thread."""
+        if self._cleanup_thread and self._cleanup_thread.is_alive():
+            return
+        
+        def loop():
+            while True:
+                try:
+                    # Run cleanup every hour, remove sessions idle > 6 hours
+                    time.sleep(3600)
+                    self._cleanup_old(max_age_hours=6)
+                except Exception as e:
+                    print(f"[SESSION] Cleanup error: {e}")
+        
+        self._cleanup_thread = threading.Thread(target=loop, daemon=True)
+        self._cleanup_thread.start()
+        print("[SESSION] Cleanup thread started")
+
+
+# Global session manager instance
+SESSION_MANAGER = SimpleSessionManager()
+
+
+def get_or_create_session(alias: Optional[str] = None) -> Dict:
+    """Convenience function to get or create a session."""
+    if alias:
+        session = SESSION_MANAGER.get_session(alias=alias)
+        if session:
+            return session
+    return SESSION_MANAGER.create_session(alias=alias)
+
+
+def get_session(session_id: str) -> Optional[Dict]:
+    """Get session by ID."""
+    return SESSION_MANAGER.get_session(session_id=session_id)
+
+
+def get_session_by_alias(alias: str) -> Optional[Dict]:
+    """Get session by alias."""
+    return SESSION_MANAGER.get_session(alias=alias)
+
+
+def list_all_sessions() -> Dict[str, Dict]:
+    """List all sessions."""
+    return SESSION_MANAGER.list_sessions()