history display

app.py

@@ -1,75 +1,68 @@
-
+
 # ./app.py
 
 """
-The Interface Skeleton - The code sets up the navigation panel and the multimodal chat interface
-
-The .then() chain: Previously, the save happened "in the background." Now, handle_save explicitly returns the new load_history() results to the history_list component, causing it to "re-render" with the new chat visible.
-
-The chat_id_state: By passing this back and forth, the app knows if it should update an existing file in the HF Dataset or create a new one.
-
-history_list.click: This is the bridge that makes the sidebar interactive. Without this event, clicking the "Recent Conversations" wouldn't do anything.
-
+This UI layer sets up a clean initialization screen. It uses a layout state logic gate: when the page is loaded, it shows a clean login dialog box. If a valid password is sent, the complete history is queried; if an empty string is submitted, history retrieval is bypassed entirely, and the main workspace is unlocked.
 """
 
-
 import gradio as gr
 from core_logic import chat_function
-from storage import save_chat, load_history, get_chat_content
+from storage import save_chat, load_history, get_chat_content, verify_access_token
 from git_agent import manage_github_repo
 
 # Theme and css parameters not included under gr.Blocks constructor for Gradio 6
 with gr.Blocks() as demo:
-    # This state keeps track of the filename for the current session
+    # Hidden states tracking variables
     chat_id_state = gr.State("")
-    
-    # Hidden state tracking variable to maintain files across the chat session
     staged_files_state = gr.State([])
-
-    with gr.Row():
+    # Session persistent tracking string holding the password token for post-saving sync triggers
+    auth_token_state = gr.State("")
+
+    # ==================== LAYER 1: AUTHENTICATION GATE (Visible by default) ====================
+    with gr.Column(visible=True) as login_layout:
+        gr.Markdown("## 🔐 CoderG Enterprise Access Gate")
+        gr.Markdown(
+            "⚠️ **Workspace Notice:** You can leave the password field blank to proceed to the workspace. "
+            "However, if you log in without a valid security key, **no past conversations or sidebar logs will be loaded**."
+        )
+        password_input = gr.Textbox(
+            label="Security Access Password", 
+            placeholder="Enter password or leave blank for sandboxed mode...", 
+            type="password"
+        )
+        login_btn = gr.Button("Unlock Workspace Environment", variant="primary")
+
+    # ==================== LAYER 2: MAIN WORKSPACE (Hidden until validation) ====================
+    with gr.Row(visible=False) as main_workspace:
+        
         # --- Left Panel: Sidebar History ---
         with gr.Column(scale=1, variant="secondary"):
             gr.Markdown("### 🛠️ Silicon Architect")
             new_btn = gr.Button("➕ New Chat", variant="primary")
             
-            # The sidebar component
+            # The sidebar component - starts empty and populates dynamically upon auth completion
             history_list = gr.Dataset(
                 components=[gr.Textbox(visible=False)], 
                 label="Recent Conversations", 
-                samples=load_history(),
+                samples=[],
                 type="values",
                 samples_per_page=20
             )
             
         # --- Center Panel: Main Core Multimodal Chat ---
         with gr.Column(scale=3):
-            # type="messages" not included as it is now default/implicit in Gradio 6
             chatbot = gr.Chatbot(show_label=False, height=700)
-            """
-            chat_input = gr.MultimodalTextbox(
-                interactive=True,
-                placeholder="Discuss architecture or ask CoderG to produce course documentation...",
-                show_label=False,
-                # FIX 1: Allow users to stack multiple files before sending
-                file_count="multiple",
-                # FIX 2: Stop rich text clipboard objects from hijacking the paste buffer
-                file_types=[".png", ".jpg", ".jpeg", ".bmp", ".pdf", ".xlsx", ".xls", ".docx", ".md", ".py", ".html", ".cs", ".js", ".json", ".csv", ".zip", ".tar.gz", ".log", ".txt"]  # Expanded file type support
-            )
-            """
-            # 1. Use a standard Textbox. It treats all paste inputs strictly as raw text strings,
-            # completely preventing the automated file-attachment generation bug.
+            
             chat_input = gr.Textbox(
                 interactive=True,
                 placeholder="Discuss architecture, paste code blocks, or ask CoderG to produce course documentation...",
                 show_label=False,
-                lines=1,        # <--- Crucial change: Reverts default Enter behavior back to sending
-                max_lines=10,   # <--- Keeps the box flexible so it expands when pasting large text such as code bases
+                lines=1,        
+                max_lines=10,   
                 scale=8,
-                submit_btn=False  # <--- Removes the forced sidebar submit button, allowing 'Enter' to natively act as the submission key
+                submit_btn=False  
             )
             
-            # 2. Wire Up the Component Handlers - 2. Provide a distinct, clear upload node that connects to your perception agent pipeline
-            # Triggered immediately when a user finishes choosing files in the file browser window
             upload_btn = gr.UploadButton(
                 "📎 Attach Documents/Images",
                 file_count="multiple",
@@ -77,7 +70,6 @@ with gr.Blocks() as demo:
                 scale=2
             )
 
-            # Visual text tracker showing exactly what files have successfully staged
             upload_status = gr.Markdown("")
 
         # --- Right Panel: Agentic Control Tower ---
@@ -104,47 +96,50 @@ with gr.Blocks() as demo:
             gr.Markdown("#### 📊 Deployment Telemetry Logs")
             output_log = gr.Markdown("_Awaiting local environment staging completion..._")
 
-    # --- LOGIC FUNCTIONS ---
-
-    # --- 1: Create a staging function to process files when uploaded ---
+    # --- UI ROUTING HANDLERS ---
+    def evaluate_login_access(password_attempt):
+        """Processes the state gate router logic step when the entry button is pushed."""
+        # 1. If it's a completely incorrect password and a master key is set, block entry completely
+        import storage
+        if storage.APP_SECRET_PASSWORD and password_attempt and not verify_access_token(password_attempt):
+            raise gr.Error("❌ Invalid security token entered. Access to environment denied.")
+            
+        # 2. Query history using input parameters (Will yield data if correct or an empty array if blank)
+        loaded_samples = load_history(password_attempt)
+        
+        # 3. Swap frame presentation layers, pipeline data to sidebar component, and commit key to internal state
+        return (
+            gr.update(visible=False),              # Hide login layout
+            gr.update(visible=True),               # Reveal main application workspace
+            gr.update(samples=loaded_samples),     # Update sidebar list view dataset target
+            password_attempt                       # Persist token state internally
+        )
+
+    # --- CORE WORKSPACE LOGIC ---
     def handle_file_upload(uploaded_files, current_staged_files):
-        """Processes files when selected via browser and appends to staging session state."""
         if not current_staged_files:
             current_staged_files = []
-        
-        # Gradio returns a list of file objects when file_count="multiple"
         for file_obj in uploaded_files:
-            # Check the property format of incoming file assets from Gradio 6
             file_path = file_obj.name if hasattr(file_obj, 'name') else file_obj
             if file_path and file_path not in current_staged_files:
                 current_staged_files.append(file_path)
-        
-        # Return a visual message showing how many files are safely staged
         status_msg = f"🟢 **{len(current_staged_files)} file(s) staged successfully and attached to next prompt.**"
         return current_staged_files, status_msg
 
     def bot_response(message, history, chat_id):
         user_content = message["text"]
-        
-        # 1. Pass a CLEAN copy of the historical conversation *before* appending new turns
-        # This ensures core_logic gets a proper history trail without duplication.
         clean_history_snapshot = list(history) 
-        
-        # 2. Now prepare the live local UI array for streaming feedback
         history.append({"role": "user", "content": user_content})
         history.append({"role": "assistant", "content": ""})
         
-        # 3. Run the generator using your clean background state snapshot
         for partial_resp in chat_function(message, clean_history_snapshot):
             history[-1]["content"] = partial_resp
             yield history
 
-    def handle_save(history, chat_id):
-        # 1. Save the actual data
+    def handle_save(history, chat_id, saved_auth_token):
+        # Pass the verified password token to authorize sync execution workflows
         new_id = save_chat(chat_id, history)
-        # 2. Get the latest from hub
-        current_list = load_history()
-        # 3. Ensure the current one is definitely at the top
+        current_list = load_history(saved_auth_token)
         if [new_id] not in current_list:
             current_list.insert(0, [new_id])
         return new_id, gr.update(samples=current_list)
@@ -155,108 +150,63 @@ with gr.Blocks() as demo:
         return content, chat_id
 
     def push_authorized(repo_name, commit_msg, files_list):
-        """Triggers git_agent to build the target repository, clean up local folders, and log tasks."""
-        # Cleanly split comma separated lists of files
         files = [f.strip() for f in files_list.split(",") if f.strip()]
-        
         if not repo_name.strip():
             yield "❌ **Deployment Aborted:** Repository name cannot be empty."
             return
-
         yield "◌ _Connecting to GitHub REST API Engine..._"
         result = manage_github_repo(repo_name.strip(), commit_msg, files)
         yield f"{result}"
 
-    # --- INTERACTION ARCHITECTURE / EVENT HANDLERS ---
+    # --- BIND EVENT LISTENER LIFECYCLES ---
+    
+    # Auth trigger layer
+    login_btn.click(
+        fn=evaluate_login_access,
+        inputs=[password_input],
+        outputs=[login_layout, main_workspace, history_list, auth_token_state]
+    )
 
-    # Hook the UploadButton event listener loop to stage chosen files right away
     upload_btn.upload(
         fn=handle_file_upload,
         inputs=[upload_btn, staged_files_state],
         outputs=[staged_files_state, upload_status]
     )
 
-    # Submission wrapper to package parameters together for your multi-format engine
-    # When submitting, we pass BOTH the text and the hidden staged files state array!
     def process_submission(message_text, current_staged_files, history, chat_id):
         if not message_text.strip() and not current_staged_files:
             return history, "", current_staged_files, ""
-            
-        # Packaging matching the identical format of core_logic expectations
-        payload = {
-            "text": message_text,
-            "files": current_staged_files
-        }
-        
-        # Stream responses through bot loops and clear inputs when complete
+        payload = {"text": message_text, "files": current_staged_files}
         for updated_history in bot_response(payload, history, chat_id):
-            # Continuously yield state update frames, wiping values upon initial loop entry
             yield updated_history, "", [], ""
 
-    # 1. Bind Enter/Submit behavior for the chat input text box
     chat_input.submit(
         fn=process_submission, 
         inputs=[chat_input, staged_files_state, chatbot, chat_id_state], 
         outputs=[chatbot, chat_input, staged_files_state, upload_status]
     ).then(
         fn=handle_save, 
-        inputs=[chatbot, chat_id_state], 
+        inputs=[chatbot, chat_id_state, auth_token_state], # Pulls preserved token state configuration
         outputs=[chat_id_state, history_list]
     )
     
-    # 2. Click Sidebar Item -> Load Content
     history_list.click(
         fn=load_past_chat, 
         inputs=[history_list], 
         outputs=[chatbot, chat_id_state]
     )
 
-    # 3. New Chat Button Initialization
     new_btn.click(
-        fn=lambda: ([], "", [], load_history(), "", "_Awaiting local environment staging completion..._"), 
-        inputs=None, 
+        fn=lambda token: ([], "", [], load_history(token), "", "_Awaiting local environment staging completion..._"), 
+        inputs=[auth_token_state], 
         outputs=[chatbot, chat_id_state, staged_files_state, history_list, upload_status, output_log]
     )
 
-    # 4. Bind the Control Tower Approve Action button
     approve_btn.click(
         fn=push_authorized, 
         inputs=[target_repo, commit_txt, staged_files], 
         outputs=[output_log]
     )
 
-    """
-    # 1. Submit Chat -> Stream Response -> Save -> Refresh Sidebar
-    chat_input.submit(
-        bot_response, 
-        [chat_input, chatbot, chat_id_state], 
-        [chatbot]
-    ).then(
-        handle_save, 
-        [chatbot, chat_id_state], 
-        [chat_id_state, history_list]
-    )
-    
-    # 2. Click Sidebar Item -> Load Content
-    history_list.click(
-        load_past_chat, 
-        [history_list], 
-        [chatbot, chat_id_state]
-    )
-
-    # 3. New Chat Button Initialization
-    new_btn.click(
-        lambda: ([], "", load_history(), "_Awaiting local environment staging completion..._"), 
-        None, 
-        [chatbot, chat_id_state, history_list, output_log]
-    )
-
-    # 4. Bind the Control Tower Approve Action button
-    approve_btn.click(
-        push_authorized, 
-        [target_repo, commit_txt, staged_files], 
-        [output_log]
-    )
-    """
-# Fully consolidated theme and styling injections down into launch() parameter fields
+# Launch UI workspace session
 demo.launch(theme=gr.themes.Soft(), css="styles.css")

app_02.py

@@ -0,0 +1,262 @@
+
+# ./app.py
+
+"""
+The Interface Skeleton - The code sets up the navigation panel and the multimodal chat interface
+
+The .then() chain: Previously, the save happened "in the background." Now, handle_save explicitly returns the new load_history() results to the history_list component, causing it to "re-render" with the new chat visible.
+
+The chat_id_state: By passing this back and forth, the app knows if it should update an existing file in the HF Dataset or create a new one.
+
+history_list.click: This is the bridge that makes the sidebar interactive. Without this event, clicking the "Recent Conversations" wouldn't do anything.
+
+"""
+
+
+import gradio as gr
+from core_logic import chat_function
+from storage import save_chat, load_history, get_chat_content
+from git_agent import manage_github_repo
+
+# Theme and css parameters not included under gr.Blocks constructor for Gradio 6
+with gr.Blocks() as demo:
+    # This state keeps track of the filename for the current session
+    chat_id_state = gr.State("")
+    
+    # Hidden state tracking variable to maintain files across the chat session
+    staged_files_state = gr.State([])
+
+    with gr.Row():
+        # --- Left Panel: Sidebar History ---
+        with gr.Column(scale=1, variant="secondary"):
+            gr.Markdown("### 🛠️ Silicon Architect")
+            new_btn = gr.Button("➕ New Chat", variant="primary")
+            
+            # The sidebar component
+            history_list = gr.Dataset(
+                components=[gr.Textbox(visible=False)], 
+                label="Recent Conversations", 
+                samples=load_history(),
+                type="values",
+                samples_per_page=20
+            )
+            
+        # --- Center Panel: Main Core Multimodal Chat ---
+        with gr.Column(scale=3):
+            # type="messages" not included as it is now default/implicit in Gradio 6
+            chatbot = gr.Chatbot(show_label=False, height=700)
+            """
+            chat_input = gr.MultimodalTextbox(
+                interactive=True,
+                placeholder="Discuss architecture or ask CoderG to produce course documentation...",
+                show_label=False,
+                # FIX 1: Allow users to stack multiple files before sending
+                file_count="multiple",
+                # FIX 2: Stop rich text clipboard objects from hijacking the paste buffer
+                file_types=[".png", ".jpg", ".jpeg", ".bmp", ".pdf", ".xlsx", ".xls", ".docx", ".md", ".py", ".html", ".cs", ".js", ".json", ".csv", ".zip", ".tar.gz", ".log", ".txt"]  # Expanded file type support
+            )
+            """
+            # 1. Use a standard Textbox. It treats all paste inputs strictly as raw text strings,
+            # completely preventing the automated file-attachment generation bug.
+            chat_input = gr.Textbox(
+                interactive=True,
+                placeholder="Discuss architecture, paste code blocks, or ask CoderG to produce course documentation...",
+                show_label=False,
+                lines=1,        # <--- Crucial change: Reverts default Enter behavior back to sending
+                max_lines=10,   # <--- Keeps the box flexible so it expands when pasting large text such as code bases
+                scale=8,
+                submit_btn=False  # <--- Removes the forced sidebar submit button, allowing 'Enter' to natively act as the submission key
+            )
+            
+            # 2. Wire Up the Component Handlers - 2. Provide a distinct, clear upload node that connects to your perception agent pipeline
+            # Triggered immediately when a user finishes choosing files in the file browser window
+            upload_btn = gr.UploadButton(
+                "📎 Attach Documents/Images",
+                file_count="multiple",
+                file_types=[".png", ".jpg", ".jpeg", ".bmp", ".pdf", ".xlsx", ".xls", ".docx", ".md", ".py", ".html", ".cs", ".js", ".json", ".csv", ".zip", ".tar.gz", ".log", ".txt"],
+                scale=2
+            )
+
+            # Visual text tracker showing exactly what files have successfully staged
+            upload_status = gr.Markdown("")
+
+        # --- Right Panel: Agentic Control Tower ---
+        with gr.Column(scale=1, variant="secondary"):
+            gr.Markdown("### 🚀 CoderG Authorization Core")
+            gr.Markdown("_Authorize code outputs to be compiled into dedicated remote repositories._")
+            
+            target_repo = gr.Textbox(
+                label="Target Repository Name", 
+                placeholder="e.g., advanced-python-course",
+                value="dynamic-course-repo"
+            )
+            commit_txt = gr.Textbox(
+                label="Commit Message", 
+                value="Automated generation via CoderG Agent"
+            )
+            staged_files = gr.Textbox(
+                label="Staged Files (Comma-separated)", 
+                value="COURSE_README.md"
+            )
+            
+            approve_btn = gr.Button("Approve & Push to GitHub", variant="primary")
+            
+            gr.Markdown("#### 📊 Deployment Telemetry Logs")
+            output_log = gr.Markdown("_Awaiting local environment staging completion..._")
+
+    # --- LOGIC FUNCTIONS ---
+
+    # --- 1: Create a staging function to process files when uploaded ---
+    def handle_file_upload(uploaded_files, current_staged_files):
+        """Processes files when selected via browser and appends to staging session state."""
+        if not current_staged_files:
+            current_staged_files = []
+        
+        # Gradio returns a list of file objects when file_count="multiple"
+        for file_obj in uploaded_files:
+            # Check the property format of incoming file assets from Gradio 6
+            file_path = file_obj.name if hasattr(file_obj, 'name') else file_obj
+            if file_path and file_path not in current_staged_files:
+                current_staged_files.append(file_path)
+        
+        # Return a visual message showing how many files are safely staged
+        status_msg = f"🟢 **{len(current_staged_files)} file(s) staged successfully and attached to next prompt.**"
+        return current_staged_files, status_msg
+
+    def bot_response(message, history, chat_id):
+        user_content = message["text"]
+        
+        # 1. Pass a CLEAN copy of the historical conversation *before* appending new turns
+        # This ensures core_logic gets a proper history trail without duplication.
+        clean_history_snapshot = list(history) 
+        
+        # 2. Now prepare the live local UI array for streaming feedback
+        history.append({"role": "user", "content": user_content})
+        history.append({"role": "assistant", "content": ""})
+        
+        # 3. Run the generator using your clean background state snapshot
+        for partial_resp in chat_function(message, clean_history_snapshot):
+            history[-1]["content"] = partial_resp
+            yield history
+
+    def handle_save(history, chat_id):
+        # 1. Save the actual data
+        new_id = save_chat(chat_id, history)
+        # 2. Get the latest from hub
+        current_list = load_history()
+        # 3. Ensure the current one is definitely at the top
+        if [new_id] not in current_list:
+            current_list.insert(0, [new_id])
+        return new_id, gr.update(samples=current_list)
+
+    def load_past_chat(selected_list):
+        chat_id = selected_list[0]
+        content = get_chat_content(chat_id)
+        return content, chat_id
+
+    def push_authorized(repo_name, commit_msg, files_list):
+        """Triggers git_agent to build the target repository, clean up local folders, and log tasks."""
+        # Cleanly split comma separated lists of files
+        files = [f.strip() for f in files_list.split(",") if f.strip()]
+        
+        if not repo_name.strip():
+            yield "❌ **Deployment Aborted:** Repository name cannot be empty."
+            return
+
+        yield "◌ _Connecting to GitHub REST API Engine..._"
+        result = manage_github_repo(repo_name.strip(), commit_msg, files)
+        yield f"{result}"
+
+    # --- INTERACTION ARCHITECTURE / EVENT HANDLERS ---
+
+    # Hook the UploadButton event listener loop to stage chosen files right away
+    upload_btn.upload(
+        fn=handle_file_upload,
+        inputs=[upload_btn, staged_files_state],
+        outputs=[staged_files_state, upload_status]
+    )
+
+    # Submission wrapper to package parameters together for your multi-format engine
+    # When submitting, we pass BOTH the text and the hidden staged files state array!
+    def process_submission(message_text, current_staged_files, history, chat_id):
+        if not message_text.strip() and not current_staged_files:
+            return history, "", current_staged_files, ""
+            
+        # Packaging matching the identical format of core_logic expectations
+        payload = {
+            "text": message_text,
+            "files": current_staged_files
+        }
+        
+        # Stream responses through bot loops and clear inputs when complete
+        for updated_history in bot_response(payload, history, chat_id):
+            # Continuously yield state update frames, wiping values upon initial loop entry
+            yield updated_history, "", [], ""
+
+    # 1. Bind Enter/Submit behavior for the chat input text box
+    chat_input.submit(
+        fn=process_submission, 
+        inputs=[chat_input, staged_files_state, chatbot, chat_id_state], 
+        outputs=[chatbot, chat_input, staged_files_state, upload_status]
+    ).then(
+        fn=handle_save, 
+        inputs=[chatbot, chat_id_state], 
+        outputs=[chat_id_state, history_list]
+    )
+    
+    # 2. Click Sidebar Item -> Load Content
+    history_list.click(
+        fn=load_past_chat, 
+        inputs=[history_list], 
+        outputs=[chatbot, chat_id_state]
+    )
+
+    # 3. New Chat Button Initialization
+    new_btn.click(
+        fn=lambda: ([], "", [], load_history(), "", "_Awaiting local environment staging completion..._"), 
+        inputs=None, 
+        outputs=[chatbot, chat_id_state, staged_files_state, history_list, upload_status, output_log]
+    )
+
+    # 4. Bind the Control Tower Approve Action button
+    approve_btn.click(
+        fn=push_authorized, 
+        inputs=[target_repo, commit_txt, staged_files], 
+        outputs=[output_log]
+    )
+
+    """
+    # 1. Submit Chat -> Stream Response -> Save -> Refresh Sidebar
+    chat_input.submit(
+        bot_response, 
+        [chat_input, chatbot, chat_id_state], 
+        [chatbot]
+    ).then(
+        handle_save, 
+        [chatbot, chat_id_state], 
+        [chat_id_state, history_list]
+    )
+    
+    # 2. Click Sidebar Item -> Load Content
+    history_list.click(
+        load_past_chat, 
+        [history_list], 
+        [chatbot, chat_id_state]
+    )
+
+    # 3. New Chat Button Initialization
+    new_btn.click(
+        lambda: ([], "", load_history(), "_Awaiting local environment staging completion..._"), 
+        None, 
+        [chatbot, chat_id_state, history_list, output_log]
+    )
+
+    # 4. Bind the Control Tower Approve Action button
+    approve_btn.click(
+        push_authorized, 
+        [target_repo, commit_txt, staged_files], 
+        [output_log]
+    )
+    """
+# Fully consolidated theme and styling injections down into launch() parameter fields
+demo.launch(theme=gr.themes.Soft(), css="styles.css")

storage.py

@@ -14,9 +14,20 @@ from huggingface_hub import HfApi, hf_hub_download
 REPO_ID = "prashantmatlani/chathistorycoderg"
 HISTORY_DIR = "./chathistory"
 
+# Pull the master password secret key from the Hugging Face Space Environment Variables
+APP_SECRET_PASSWORD = os.getenv("APP_PASSWORD", "")
+
 # Initialize the API with your token
 api = HfApi(token=os.getenv("HF_TOKEN"))
 
+def verify_access_token(user_password_input):
+    """
+    Validates the user's password input against the Space environment secret.
+    Accepts blank input gracefully if no environment secret variable is configured.
+    """
+    target_password = APP_SECRET_PASSWORD if APP_SECRET_PASSWORD is not None else ""
+    return user_password_input == target_password
+
 def save_chat(chat_id, history):
     """Saves chat to local subdirectory and syncs to Hugging Face Dataset."""
     if not os.path.exists(HISTORY_DIR):
@@ -46,55 +57,54 @@ def save_chat(chat_id, history):
         
     return chat_id
 
-"""
-def load_history():
-    # Retrieves list of chat IDs from the Hub to populate the sidebar.
-    try:
-        # We pull the list from the Hub so the sidebar reflects all saved sessions
-        files = api.list_repo_files(repo_id=REPO_ID, repo_type="dataset")
-        chat_files = [f.split("/")[-1].replace(".json", "") for f in files if f.startswith("chats/")]
-        # IMPORTANT: Sorted by newest first; return as list of lists for Gradio Dataset component
-        return [[f] for f in sorted(chat_files, reverse=True)]
-    except:
+def load_history(user_password_input=""):
+    """
+    Retrieves list of chat IDs from the Hub, explicitly sorted by true modification time.
+    Strictly yields an empty list if a required password is left blank or incorrect.
+    """
+    # Guardrail 1: If a master password exists in the space environments and the user left it blank, block history
+    if APP_SECRET_PASSWORD and not user_password_input:
+        print("[*] Security Guardrail: Empty password submitted. Bypassing history retrieval.")
+        return []
+        
+    # Guardrail 2: Verify the password matches explicitly before querying storage
+    if not verify_access_token(user_password_input):
+        print("[!] Security Guardrail: Invalid access credentials submitted.")
         return []
-"""
 
-def load_history():
-    """Retrieves list of chat IDs from the Hub with a fail-safe chronological sorting fallback."""
     try:
-        # 1. Attempt to get rich metadata for chronological sorting
+        # 1. Fetch rich metadata for chronological sorting
         repo_info = api.repo_info(repo_id=REPO_ID, repo_type="dataset", files_metadata=True)
         
         chat_files_meta = []
         if repo_info and hasattr(repo_info, 'siblings'):
             for f in repo_info.siblings:
-                # Safe startswith check
-                if f.rfind('chats/') == 0:  
-                    filename_idx = f.rfind('/') + 1
-                    chat_id = f[filename_idx:].replace(".json", "")
-                    
-                    # Safely extract last_modified timestamp if it exists
+                # FIX: Target f.rname string property explicitly instead of the bare object instance
+                file_path = getattr(f, 'rname', '')
+                
+                if file_path.startswith("chats/"):
+                    chat_id = file_path.split("/")[-1].replace(".json", "")
+                    # Safely extract last_modified timestamp metadata if available
                     last_modified = getattr(f, 'last_modified', None)
                     chat_files_meta.append((chat_id, last_modified))
             
-            # Sort by timestamp if available; otherwise fall back to string name
+            # Sort with newest file updates positioned dynamically at index [0]
             chat_files_meta.sort(key=lambda x: x[1] if x[1] is not None else x[0], reverse=True)
             return [[item[0]] for item in chat_files_meta]
 
     except Exception as metadata_error:
-        # Log the error so it's visible in your HF Space logs instead of swallowing it
-        print(f"[!] Metadata fetch failed, switching to fallback string sort: {metadata_error}")
+        print(f"[!] Primary metadata pipeline exception: {metadata_error}. Launching clean fallback channel...")
         
-    # 2. Fallback Layer: If metadata calls fail, immediately run your original working string method
+    # 2. Complete Independent Fallback Channel (Prevents file descriptor socket reuse errors)
     try:
-        files = api.list_repo_files(repo_id=REPO_ID, repo_type="dataset")
+        fallback_api = HfApi(token=os.getenv("HF_TOKEN"))
+        files = fallback_api.list_repo_files(repo_id=REPO_ID, repo_type="dataset")
         chat_files = [f.split("/")[-1].replace(".json", "") for f in files if f.startswith("chats/")]
         return [[f] for f in sorted(chat_files, reverse=True)]
     except Exception as fallback_error:
-        print(f"[!!] Total storage access failure: {fallback_error}")
+        print(f"[!!] Critical Storage Interface Breakdown: {fallback_error}")
         return []
 
-
 def get_chat_content(chat_id):
     """Loads a specific chat's content from the Hub or local cache."""
     filename = f"chats/{chat_id}.json"

storage_00.py

@@ -0,0 +1,123 @@
+
+# ./storage_00.py
+
+"""
+Persistence Layer - Handles the "Save/Load" functionality using Hugging Face Dataset as a database
+"""
+
+import json
+import os
+from datetime import datetime
+from huggingface_hub import HfApi, hf_hub_download
+
+# --- CONFIGURATION ---
+REPO_ID = "prashantmatlani/chathistorycoderg"
+HISTORY_DIR = "./chathistory"
+
+# Initialize the API with your token
+api = HfApi(token=os.getenv("HF_TOKEN"))
+
+def save_chat(chat_id, history):
+    """Saves chat to local subdirectory and syncs to Hugging Face Dataset."""
+    if not os.path.exists(HISTORY_DIR):
+        os.makedirs(HISTORY_DIR)
+    
+    # Generate a unique ID if none exists (e.g., for a brand new chat)
+    if not chat_id:
+        chat_id = datetime.now().strftime("%m%d%Y_%H%M%S")
+    
+    filename = f"{chat_id}.json"
+    local_path = os.path.join(HISTORY_DIR, filename)
+    
+    # 1. Save Locally
+    with open(local_path, "w", encoding="utf-8") as f:
+        json.dump(history, f, indent=4)
+    
+    # 2. Sync to Hugging Face Dataset (Master Stroke Persistence)
+    try:
+        api.upload_file(
+            path_or_fileobj=local_path,
+            path_in_repo=f"chats/{filename}",
+            repo_id=REPO_ID,
+            repo_type="dataset"
+        )
+    except Exception as e:
+        print(f"Cloud Sync Warning: {e}")
+        
+    return chat_id
+
+"""
+def load_history():
+    # Retrieves list of chat IDs from the Hub to populate the sidebar.
+    try:
+        # We pull the list from the Hub so the sidebar reflects all saved sessions
+        files = api.list_repo_files(repo_id=REPO_ID, repo_type="dataset")
+        chat_files = [f.split("/")[-1].replace(".json", "") for f in files if f.startswith("chats/")]
+        # IMPORTANT: Sorted by newest first; return as list of lists for Gradio Dataset component
+        return [[f] for f in sorted(chat_files, reverse=True)]
+    except:
+        return []
+"""
+
+def load_history():
+    """Retrieves list of chat IDs from the Hub with a fail-safe chronological sorting fallback."""
+    try:
+        # 1. Attempt to get rich metadata for chronological sorting
+        repo_info = api.repo_info(repo_id=REPO_ID, repo_type="dataset", files_metadata=True)
+        
+        chat_files_meta = []
+        if repo_info and hasattr(repo_info, 'siblings'):
+            for f in repo_info.siblings:
+                # Safe startswith check
+                if f.rfind('chats/') == 0:  
+                    filename_idx = f.rfind('/') + 1
+                    chat_id = f[filename_idx:].replace(".json", "")
+                    
+                    # Safely extract last_modified timestamp if it exists
+                    last_modified = getattr(f, 'last_modified', None)
+                    chat_files_meta.append((chat_id, last_modified))
+            
+            # Sort by timestamp if available; otherwise fall back to string name
+            chat_files_meta.sort(key=lambda x: x[1] if x[1] is not None else x[0], reverse=True)
+            return [[item[0]] for item in chat_files_meta]
+
+    except Exception as metadata_error:
+        # Log the error so it's visible in your HF Space logs instead of swallowing it
+        print(f"[!] Metadata fetch failed, switching to fallback string sort: {metadata_error}")
+        
+    # 2. Fallback Layer: If metadata calls fail, immediately run original working string method
+    try:
+        files = api.list_repo_files(repo_id=REPO_ID, repo_type="dataset")
+        chat_files = [f.split("/")[-1].replace(".json", "") for f in files if f.startswith("chats/")]
+        return [[f] for f in sorted(chat_files, reverse=True)]
+    except Exception as fallback_error:
+        print(f"[!!] Total storage access failure: {fallback_error}")
+        return []
+
+
+def get_chat_content(chat_id):
+    """Loads a specific chat's content from the Hub or local cache."""
+    filename = f"chats/{chat_id}.json"
+    local_path = os.path.join(HISTORY_DIR, f"{chat_id}.json")
+    
+    try:
+        # Ensure local dir exists
+        if not os.path.exists(HISTORY_DIR):
+            os.makedirs(HISTORY_DIR)
+            
+        # Download from Hub to keep local state fresh
+        from huggingface_hub import hf_hub_download
+        downloaded_path = hf_hub_download(
+            repo_id=REPO_ID, 
+            repo_type="dataset", 
+            filename=filename,
+            token=os.getenv("HF_TOKEN")
+        )
+        with open(downloaded_path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        # Fallback to local if Hub is unreachable
+        if os.path.exists(local_path):
+            with open(local_path, "r", encoding="utf-8") as f:
+                return json.load(f)
+    return []