api endpoints for UI migration v4

app.py

@@ -225,8 +225,8 @@ def create_mobile_optimized_interface():
             with gr.Row():
                 # User Selection Dropdown
                 user_dropdown = gr.Dropdown(
-                    choices=["Admin_J", "Dev_K", "Dev_H", "Dev_A", "Test_Any"],
-                    value="Test_Any",
+                    choices=["ADMINONLY"],
+                    value="ADMINONLY",
                     label="User",
                     show_label=False,
                     container=False,
@@ -237,7 +237,7 @@ def create_mobile_optimized_interface():
                 
                 session_info = gr.Textbox(
                     label="Session Info",
-                    value=f"Session: {str(uuid.uuid4())[:8]} | User: Test_Any | Interactions: 0",
+                    value=f"Session: {str(uuid.uuid4())[:8]} | User: ADMINONLY | Interactions: 0",
                     max_lines=1,
                     show_label=False,
                     container=False,
@@ -434,6 +434,36 @@ def create_mobile_optimized_interface():
             save_prefs_btn = gr.Button("Save Preferences", variant="primary")
             interface_components['save_prefs_btn'] = save_prefs_btn
         
+        # UI-specific chat handler - enforces ADMINONLY only
+        def ui_chat_handler(message, history, user_id="ADMINONLY", session_text=""):
+            """
+            UI-specific chat handler - enforces ADMINONLY only.
+            This wrapper ensures UI cannot bypass validation.
+            """
+            # Force ADMINONLY - UI dropdown only has this option, but add safety check
+            if user_id != "ADMINONLY":
+                logger.warning(f"UI attempted to use user_id {user_id}, enforcing ADMINONLY")
+                user_id = "ADMINONLY"
+            
+            # Validate with UI source
+            is_valid, session_id, validated_user_id, error_msg = _validate_chat_inputs(
+                message, history, user_id, session_text, source="ui"
+            )
+            
+            if not is_valid:
+                logger.error(f"Invalid UI chat input: {error_msg}")
+                error_result = _create_error_response(error_msg, history)
+                return _build_dynamic_return_values(error_result, "", _interface_components)
+            
+            # Process with validated ADMINONLY user
+            try:
+                result = process_message(message, history, session_id, validated_user_id)
+                return result
+            except Exception as e:
+                logger.error(f"Error in ui_chat_handler: {e}", exc_info=True)
+                error_result = _create_error_response(f"Processing error: {str(e)}", history)
+                return _build_dynamic_return_values(error_result, "", _interface_components)
+        
         # Wire up the submit handler INSIDE the gr.Blocks context
         if 'send_btn' in interface_components and 'message_input' in interface_components and 'chatbot' in interface_components:
             # Store interface components globally for dynamic return values
@@ -451,7 +481,7 @@ def create_mobile_optimized_interface():
                 inputs.append(interface_components['session_info'])
             
             interface_components['send_btn'].click(
-                fn=chat_handler_fn,
+                fn=ui_chat_handler,  # Use UI-specific handler
                 inputs=inputs,
                 outputs=outputs
             )
@@ -461,11 +491,10 @@ def create_mobile_optimized_interface():
                 def new_session(user_id):
                     """
                     Create new session with validation and database initialization.
-                    Enhanced API endpoint: /new_session
-                    Complete implementation with no placeholders.
+                    UI version - enforces ADMINONLY.
                     """
-                    # Validate user_id
-                    validated_user_id = _validate_user_id(user_id)
+                    # Validate user_id for UI
+                    validated_user_id = _validate_user_id(user_id, source="ui")
                     
                     # Generate new session ID
                     new_session_id = str(uuid.uuid4())[:8]
@@ -498,12 +527,11 @@ def create_mobile_optimized_interface():
                 def update_session_info(user_id, session_text):
                     """
                     Update session info with robust parsing and validation.
-                    Enhanced API endpoint: /update_session_info
-                    Complete implementation with no placeholders.
+                    UI version - enforces ADMINONLY.
                     Preserves session continuity - never generates new session ID.
                     """
-                    # Validate user_id
-                    validated_user_id = _validate_user_id(user_id)
+                    # Validate user_id for UI
+                    validated_user_id = _validate_user_id(user_id, source="ui")
                     
                     # Extract session_id (never generates new one - preserves session continuity)
                     try:
@@ -700,7 +728,7 @@ def create_mobile_optimized_interface():
                     
                     # Try to get current session_id and user_id
                     session_id = None
-                    user_id = "Test_Any"
+                    user_id = "ADMINONLY"  # UI default
                     
                     try:
                         # Try to get from global interface components if available
@@ -712,7 +740,7 @@ def create_mobile_optimized_interface():
                                 import re
                                 user_match = re.search(r'User:\s*([^|]+)', session_info_text)
                                 if user_match:
-                                    user_id = _validate_user_id(user_match.group(1).strip())
+                                    user_id = _validate_user_id(user_match.group(1).strip(), source="api")
                     except Exception as e:
                         logger.debug(f"Could not extract session info for preferences: {e}")
                     
@@ -820,21 +848,84 @@ _settings_panel_visible = False
 # Global preferences cache (fallback when database unavailable)
 _user_preferences_cache = {}
 
-def _validate_user_id(user_id: str) -> str:
+def _ensure_user_exists(user_id: str):
+    """
+    Ensure user exists in database (auto-create if new).
+    Backend maintains user information - no hardcoded lists.
+    """
+    try:
+        global orchestrator
+        if orchestrator and hasattr(orchestrator, 'context_manager'):
+            context_manager = orchestrator.context_manager
+            
+            # Check if user exists in user_contexts table
+            import sqlite3
+            db_path = getattr(context_manager, 'db_path', 'sessions.db')
+            conn = sqlite3.connect(db_path)
+            cursor = conn.cursor()
+            
+            # Check if user exists
+            cursor.execute("SELECT user_id FROM user_contexts WHERE user_id = ?", (user_id,))
+            exists = cursor.fetchone()
+            
+            if not exists:
+                # Auto-create user in database
+                cursor.execute("""
+                    INSERT OR IGNORE INTO user_contexts (user_id, persona_summary, updated_at)
+                    VALUES (?, ?, datetime('now'))
+                """, (user_id, ""))
+                conn.commit()
+                logger.info(f"Auto-created new API user: {user_id}")
+            else:
+                logger.debug(f"User {user_id} already exists in database")
+            
+            conn.close()
+    except Exception as e:
+        logger.error(f"Error ensuring user exists: {e}", exc_info=True)
+        # Non-fatal - continue with user_id as-is
+
+def _validate_user_id(user_id: str, source: str = "api") -> str:
     """
-    Validate and return valid user_id.
+    Validate user_id based on source (UI or API).
+    UI: Only ADMINONLY allowed
+    API: Admin_J base user, but accepts any user_id (auto-creates in database)
     
     Args:
         user_id: User identifier to validate
+        source: "ui" or "api" to determine validation rules
     
     Returns:
-        Validated user_id (defaults to 'Test_Any' if invalid)
+        Validated user_id (for UI: ADMINONLY, for API: provided user_id or Admin_J)
     """
-    allowed_users = ['Admin_J', 'Dev_K', 'Dev_H', 'Dev_A', 'Test_Any']
-    if user_id not in allowed_users:
-        logger.warning(f"Invalid user_id: {user_id}, defaulting to Test_Any")
-        return "Test_Any"
-    return user_id
+    if source == "ui":
+        # UI can ONLY use ADMINONLY
+        if user_id != "ADMINONLY":
+            logger.warning(f"UI attempted invalid user_id: {user_id}, enforcing ADMINONLY")
+            return "ADMINONLY"
+        return "ADMINONLY"
+    
+    else:  # API source
+        # API: Base allowed user is Admin_J
+        api_base_user = "Admin_J"
+        
+        # If provided user_id is Admin_J, allow it
+        if user_id == api_base_user:
+            return user_id
+        
+        # For any other user_id from API, validate format and auto-create in database
+        # Allow any non-empty, valid string (alphanumeric + underscore, max 50 chars)
+        if user_id and isinstance(user_id, str):
+            # Basic validation: alphanumeric + underscore, no spaces, reasonable length
+            import re
+            if re.match(r'^[a-zA-Z0-9_]{1,50}$', user_id):
+                # Valid format - auto-create user in database
+                _ensure_user_exists(user_id)
+                logger.info(f"API user validated/created: {user_id}")
+                return user_id
+        
+        # Invalid format - default to Admin_J
+        logger.warning(f"Invalid API user_id format: {user_id}, defaulting to Admin_J")
+        return api_base_user
 
 def _extract_session_id(session_text: str, allow_generate: bool = True) -> str:
     """
@@ -969,7 +1060,8 @@ def _create_error_response(error_msg: str, history: list = None) -> tuple:
         ""                       # skills_html
     )
 
-def _validate_chat_inputs(message: str, history, user_id: str, session_text: str) -> tuple:
+def _validate_chat_inputs(message: str, history, user_id: str, 
+                         session_text: str, source: str = "api") -> tuple:
     """
     Validate all chat handler inputs comprehensively.
     
@@ -978,6 +1070,7 @@ def _validate_chat_inputs(message: str, history, user_id: str, session_text: str
         history: Chat history list
         user_id: User identifier
         session_text: Session information text
+        source: "ui" or "api" - determines validation rules
     
     Returns:
         Tuple of (is_valid: bool, session_id: str, validated_user_id: str, error_msg: str)
@@ -1005,8 +1098,8 @@ def _validate_chat_inputs(message: str, history, user_id: str, session_text: str
         logger.warning(f"Invalid history type: {type(history)}, converting to list")
         history = []
     
-    # Validate user_id
-    validated_user_id = _validate_user_id(user_id)
+    # Validate user_id with source-aware validation
+    validated_user_id = _validate_user_id(user_id, source=source)
     
     # Extract session_id
     try:
@@ -1185,7 +1278,7 @@ def process_with_metrics(message, session_id, user_id):
         logger.error(f"Error in process_with_metrics: {e}", exc_info=True)
         return None
 
-async def process_message_async(message: str, history: Optional[List], session_id: str, user_id: str = "Test_Any") -> Tuple[List, str, dict, dict, dict, str, str]:
+async def process_message_async(message: str, history: Optional[List], session_id: str, user_id: str = "Admin_J") -> Tuple[List, str, dict, dict, dict, str, str]:
     """
     Process message with full orchestration system
     Returns (updated_history, empty_string, reasoning_data, performance_data, context_data, session_id, skills_html)
@@ -1596,7 +1689,7 @@ def _build_dynamic_return_values(result: tuple, skills_content: str, interface_c
     
     return tuple(return_values)
 
-def process_message(message: str, history: Optional[List], session_id: Optional[str] = None, user_id: str = "Test_Any") -> tuple:
+def process_message(message: str, history: Optional[List], session_id: Optional[str] = None, user_id: str = "Admin_J") -> tuple:
     """
     Synchronous wrapper for async processing
     Returns dynamic tuple based on available interface components
@@ -1658,14 +1751,14 @@ def process_message(message: str, history: Optional[List], session_id: Optional[
 # Decorate the chat handler with GPU if available
 if SPACES_GPU_AVAILABLE and GPU is not None:
     @GPU  # This decorator is detected by HF Spaces for ZeroGPU allocation
-    def gpu_chat_handler(message, history, user_id="Test_Any", session_text=""):
+    def gpu_chat_handler(message, history, user_id="Admin_J", session_text=""):
         """
         Handle chat messages with GPU support - Enhanced with validation.
         Complete implementation with no placeholders.
         """
-        # Validate inputs before processing
+        # Validate inputs before processing (API source)
         is_valid, session_id, validated_user_id, error_msg = _validate_chat_inputs(
-            message, history, user_id, session_text
+            message, history, user_id, session_text, source="api"
         )
         
         if not is_valid:
@@ -1682,15 +1775,15 @@ if SPACES_GPU_AVAILABLE and GPU is not None:
             error_result = _create_error_response(f"Processing error: {str(e)}", history)
             return _build_dynamic_return_values(error_result, "", _interface_components)
     
-    def safe_gpu_chat_handler(message, history, user_id="Test_Any", session_text=""):
+    def safe_gpu_chat_handler(message, history, user_id="Admin_J", session_text=""):
         """
         Wrapper to catch any exceptions from GPU decorator cleanup phase.
         Enhanced with comprehensive validation and error handling.
         Complete implementation with no placeholders.
         """
-        # Input validation first
+        # Input validation first (API source)
         is_valid, session_id, validated_user_id, error_msg = _validate_chat_inputs(
-            message, history, user_id, session_text
+            message, history, user_id, session_text, source="api"
         )
         
         if not is_valid:
@@ -1730,15 +1823,15 @@ if SPACES_GPU_AVAILABLE and GPU is not None:
     
     chat_handler_fn = safe_gpu_chat_handler
 else:
-    def chat_handler_wrapper(message, history, user_id="Test_Any", session_text=""):
+    def chat_handler_wrapper(message, history, user_id="Admin_J", session_text=""):
         """
         Wrapper to handle session ID - Enhanced with validation.
         Process Flow functionality moved to logs as per design.
         Complete implementation with no placeholders.
         """
-        # Validate inputs
+        # Validate inputs (API source)
         is_valid, session_id, validated_user_id, error_msg = _validate_chat_inputs(
-            message, history, user_id, session_text
+            message, history, user_id, session_text, source="api"
         )
         
         if not is_valid: