updates

app.py

@@ -1,15 +1,21 @@
 import gradio as gr
 import os
+import json
 import shutil
+import traceback
 from e2b_desktop import Sandbox
 from huggingface_hub import upload_folder, login
 from smolagents.monitoring import LogLevel
 from textwrap import dedent
+import time
+from threading import Timer
 
 from e2bqwen import QwenVLAPIModel, E2BVisionAgent
 
 E2B_API_KEY = os.getenv("E2B_API_KEY")
 SANDBOXES = {}
+SANDBOX_METADATA = {}
+SANDBOX_TIMEOUT = 300
 WIDTH = 1920
 HEIGHT = 1440
 TMP_DIR = './tmp/'
@@ -93,6 +99,17 @@ custom_css = """
     background-color: #e74c3c;
 }
 
+.status-error {
+    background-color: #e74c3c;
+    animation: blink-error 1s infinite;
+}
+
+@keyframes blink-error {
+    0% { background-color: rgba(231, 76, 60, 1); }
+    50% { background-color: rgba(231, 76, 60, 0.4); }
+    100% { background-color: rgba(231, 76, 60, 1); }
+}
+
 @keyframes blink {
     0% { background-color: rgba(46, 204, 113, 1); }  /* Green at full opacity */
     50% { background-color: rgba(46, 204, 113, 0.4); }  /* Green at 40% opacity */
@@ -100,19 +117,109 @@ custom_css = """
 }
 """
 
+
 html_template = """
     <div class="sandbox-outer-wrapper">
       <div class="sandbox-container">
           <img src="https://huggingface.co/datasets/lvwerra/admin/resolve/main/desktop_scaled.png" class="sandbox-background" />
           <div class="status-text">{status_text}</div>
           <div class="status-indicator {status_class}"></div>
-          <iframe 
+          <iframe id="sandbox-iframe"
               src="{stream_url}" 
               class="sandbox-iframe"
+              style="display: block;"
               allowfullscreen>
           </iframe>
+          <img id="bsod-image"
+              src="https://huggingface.co/datasets/mfarre/servedfiles/resolve/main/blue_screen_of_death.gif"
+              class="bsod-image"
+              style="display: none; position: absolute; top: 10%; left: 25%; width: 400px; height: 300px; border: 4px solid #444444;"
+          />
       </div>
-    </div>"""
+    </div>
+"""
+
+custom_js = """
+function() {
+    // Function to check if sandbox is timing out
+    const checkSandboxTimeout = function() {
+        const timeElement = document.getElementById('sandbox-creation-time');
+        
+        if (timeElement) {
+            const creationTime = parseFloat(timeElement.getAttribute('data-time'));
+            const timeoutValue = parseFloat(timeElement.getAttribute('data-timeout'));
+            const currentTime = Math.floor(Date.now() / 1000); // Current time in seconds
+            
+            const elapsedTime = currentTime - creationTime;
+            console.log("Sandbox running for: " + elapsedTime + " seconds of " + timeoutValue + " seconds");
+            
+            // If we've exceeded the timeout, show BSOD
+            if (elapsedTime >= timeoutValue) {
+                console.log("Sandbox timeout! Showing BSOD");
+                showBSOD('Error');
+                // Don't set another timeout, we're done checking
+                return;
+            }
+        }
+        
+        // Continue checking every 5 seconds
+        setTimeout(checkSandboxTimeout, 5000);
+    };
+    
+    const showBSOD = function(statusText = 'Error') {
+        console.log("Showing BSOD with status: " + statusText);
+        const iframe = document.getElementById('sandbox-iframe');
+        const bsod = document.getElementById('bsod-image');
+        
+        if (iframe && bsod) {
+            iframe.style.display = 'none';
+            bsod.style.display = 'block';
+            
+            // Update status indicator
+            const statusIndicator = document.querySelector('.status-indicator');
+            const statusTextElem = document.querySelector('.status-text');
+            
+            if (statusIndicator) {
+                statusIndicator.className = 'status-indicator status-error';
+            }
+            
+            if (statusTextElem) {
+                statusTextElem.innerText = statusText;
+            }
+        }
+    };
+    
+    // Function to monitor for error messages
+    const monitorForErrors = function() {
+        console.log("Error monitor started");
+        const resultsInterval = setInterval(function() {
+            const resultsElements = document.querySelectorAll('textarea, .output-text');
+            for (let elem of resultsElements) {
+                const content = elem.value || elem.innerText || '';
+                if (content.includes('Error running agent:')) {
+                    console.log("Error detected!");
+                    showBSOD('Error');
+                    clearInterval(resultsInterval);
+                    break;
+                }
+            }
+        }, 1000);
+    };
+    
+    // Start monitoring for timeouts immediately
+    checkSandboxTimeout();
+    
+    // Start monitoring for errors
+    setTimeout(monitorForErrors, 3000);
+    
+    // Also monitor for errors after button clicks
+    document.addEventListener('click', function(e) {
+        if (e.target.tagName === 'BUTTON') {
+            setTimeout(monitorForErrors, 3000);
+        }
+    });
+}
+"""
 
 def upload_to_hf_and_remove(folder_path):
 
@@ -141,17 +248,69 @@ def upload_to_hf_and_remove(folder_path):
         print(f"Error during upload or cleanup: {str(e)}")
         raise
 
+def cleanup_sandboxes():
+    """Remove sandboxes that haven't been accessed for more than 5 minutes"""
+    current_time = time.time()
+    sandboxes_to_remove = []
+    
+    for session_id, metadata in SANDBOX_METADATA.items():
+        if current_time - metadata['last_accessed'] > SANDBOX_TIMEOUT:
+            sandboxes_to_remove.append(session_id)
+    
+    for session_id in sandboxes_to_remove:
+        if session_id in SANDBOXES:
+            try:
+                # Upload data before removing if needed
+                data_dir = os.path.join(TMP_DIR, session_id)
+                if os.path.exists(data_dir):
+                    upload_to_hf_and_remove(data_dir)
+                
+                # Close the sandbox
+                SANDBOXES[session_id].kill()
+                del SANDBOXES[session_id]
+                del SANDBOX_METADATA[session_id]
+                print(f"Cleaned up sandbox for session {session_id}")
+            except Exception as e:
+                print(f"Error cleaning up sandbox {session_id}: {str(e)}")
+
 
 def get_or_create_sandbox(session_hash):
-    if session_hash not in SANDBOXES:
-        print(f"Creating new sandbox for session {session_hash}")
-        desktop = Sandbox(api_key=E2B_API_KEY, resolution=(WIDTH, HEIGHT), dpi=96)
-        desktop.stream.start(require_auth=True)
-        SANDBOXES[session_hash] = desktop
-    return SANDBOXES[session_hash]
+    current_time = time.time()
+    
+    # Check if sandbox exists and is still valid
+    if (session_hash in SANDBOXES and 
+        session_hash in SANDBOX_METADATA and
+        current_time - SANDBOX_METADATA[session_hash]['created_at'] < SANDBOX_TIMEOUT):
+        
+        # Update last accessed time
+        SANDBOX_METADATA[session_hash]['last_accessed'] = current_time
+        return SANDBOXES[session_hash]
+    
+    # Close existing sandbox if it exists but is too old
+    if session_hash in SANDBOXES:
+        try:
+            print(f"Closing expired sandbox for session {session_hash}")
+            SANDBOXES[session_hash].kill()
+        except Exception as e:
+            print(f"Error closing expired sandbox: {str(e)}")
+    
+    # Create new sandbox
+    print(f"Creating new sandbox for session {session_hash}")
+    desktop = Sandbox(api_key=E2B_API_KEY, resolution=(WIDTH, HEIGHT), dpi=96, timeout=SANDBOX_TIMEOUT)
+    desktop.stream.start(require_auth=True)
+    
+    # Store sandbox with metadata
+    SANDBOXES[session_hash] = desktop
+    SANDBOX_METADATA[session_hash] = {
+        'created_at': current_time,
+        'last_accessed': current_time
+    }
+    
+    return desktop
 
 def update_html(interactive_mode, request: gr.Request):
-    desktop = get_or_create_sandbox(request.session_hash)
+    session_hash = request.session_hash
+    desktop = get_or_create_sandbox(session_hash)
     auth_key = desktop.stream.get_auth_key()
     
     # Add view_only parameter based on interactive_mode
@@ -162,19 +321,37 @@ def update_html(interactive_mode, request: gr.Request):
     status_class = "status-interactive" if interactive_mode else "status-view-only"
     status_text = "Interactive" if interactive_mode else "View Only"
     
+    creation_time = SANDBOX_METADATA[session_hash]['created_at'] if session_hash in SANDBOX_METADATA else time.time()
+
     html_content = html_template.format(
         stream_url=stream_url,
         status_class=status_class,
-        status_text=status_text
+        status_text=status_text,
+        iframe_style="display: block;",
+        bsod_style="display: none;"
     )
+
+    # Add hidden field with creation time for JavaScript to use
+    html_content += f'<div id="sandbox-creation-time" style="display:none;" data-time="{creation_time}" data-timeout="{SANDBOX_TIMEOUT}"></div>'
+    
     return html_content
 
+def generate_interaction_id(request):
+    """Generate a unique ID combining session hash and timestamp"""
+    return f"{request.session_hash}_{int(time.time())}"
+
+def save_final_status(folder, status, details = None):
+    a = open(os.path.join(folder,"status.json"),"w")
+    a.write(json.dumps({"status":status,"details":str(details)}))
+    a.close()
+
 def run_agent_task(task_input, interactive_mode, request: gr.Request):
     session_hash = request.session_hash
+    interaction_id = generate_interaction_id(request)
     desktop = get_or_create_sandbox(session_hash)
     
     # Create data directory for this session
-    data_dir = os.path.join(TMP_DIR, session_hash)
+    data_dir = os.path.join(TMP_DIR, interaction_id)
     if not os.path.exists(data_dir):
         os.makedirs(data_dir)
     
@@ -185,7 +362,7 @@ def run_agent_task(task_input, interactive_mode, request: gr.Request):
         data_dir=data_dir,
         desktop=desktop,
         max_steps=200,
-        verbosity_level=LogLevel.DEBUG,
+        verbosity_level=LogLevel.INFO,
         planning_interval=5,
     )
     
@@ -206,21 +383,26 @@ def run_agent_task(task_input, interactive_mode, request: gr.Request):
     
     try:
         # Run the agent
+        r
         result = agent.run(full_task)
+        save_final_status(data_dir, "completed", details = result)
         
         interactive_mode = True        
         return f"Task completed: {result}", update_html(interactive_mode, request)
     except Exception as e:
-        error_message = f"Error running agent: {str(e)}"
+        error_message = f"Error running agent: {str(e)} Details {traceback.format_exc()}"
+        save_final_status(data_dir, "failed", details = error_message)
+
         print(error_message)
         interactive_mode = True
-        return error_message, update_html(interactive_mode, request)
+        # return error_message, update_html(interactive_mode, request)
+        return error_message
     finally:
         upload_to_hf_and_remove(data_dir)
 
 
 # Create a Gradio app with Blocks
-with gr.Blocks(css=custom_css) as demo:
+with gr.Blocks(css=custom_css, js=custom_js) as demo:
     gr.HTML("""<h1 style="text-align: center">Personal Computer Assistant</h1>""")
     
     # HTML output with simulated image and iframe
@@ -248,7 +430,8 @@ with gr.Blocks(css=custom_css) as demo:
     # Results output
     results_output = gr.Textbox(
         label="Results",
-        interactive=False
+        interactive=False,
+        elem_id="results-output"
     )
 
     # Update button
@@ -273,4 +456,5 @@ with gr.Blocks(css=custom_css) as demo:
 
 # Launch the app
 if __name__ == "__main__":
+    Timer(60, cleanup_sandboxes).start()  # Run every minute
     demo.launch()

e2bqwen.py

@@ -279,10 +279,9 @@ REMEMBER TO ALWAYS CLICK IN THE MIDDLE OF THE TEXT, NOT ON THE SIDE, NOT UNDER.
     def store_metadata_to_file(self, agent) -> None:
         metadata_path = os.path.join(self.data_dir, "metadata.json")
         output = {}
-        output['memory'] = self.write_memory_to_messages()
-        output['total_token_counts']  = agent.monitor.get_total_token_counts()
+        output_memory  = self.write_memory_to_messages()
         a = open(metadata_path,"w")
-        a.write(json.dumps(output))
+        a.write(json.dumps(output_memory))
         a.close()
 
     def write_memory_to_messages(self) -> List[Dict[str, Any]]: