Update app.py

app.py

@@ -7,19 +7,21 @@ import io
 import socket
 import random
 import string
+import datetime
 import ast
 import re
 from huggingface_hub import HfApi, snapshot_download
 
 # === Config ===
 DATASET_REPO = "Devity4756/Terminal"
-HF_TOKEN = os.environ.get("HF_TOKEN")
+HF_TOKEN = os.environ.get("HF_TOKEN", "")
 if HF_TOKEN:
     api = HfApi(token=HF_TOKEN)
 else:
     api = None
     print("Warning: HF_TOKEN not found. Save functionality will be limited.")
 
+# Use dataset workspace directly
 WORKDIR = "workspace"
 os.makedirs(WORKDIR, exist_ok=True)
 
@@ -28,22 +30,23 @@ VIRTUAL_HOME = os.path.join(WORKDIR, "Alex")
 os.makedirs(VIRTUAL_HOME, exist_ok=True)
 PATH_MAP = {"Alex": VIRTUAL_HOME}
 
-# === Restore state ===
+# === Restore state from dataset ===
 try:
     if HF_TOKEN:
         snapshot_path = snapshot_download(
             repo_id=DATASET_REPO,
             repo_type="dataset",
-            token=HF_TOKEN
+            token=HF_TOKEN,
+            local_dir=WORKDIR  # Download directly to workspace
         )
-        shutil.copytree(snapshot_path, WORKDIR, dirs_exist_ok=True)
+        print(f"Restored dataset data to: {WORKDIR}")
     else:
         print("Cannot restore state without HF_TOKEN")
 except Exception as e:
     print("No previous data restored:", e)
 
 # === Track current working directory & running process ===
-current_dir = WORKDIR
+current_dir = VIRTUAL_HOME  # Start in workspace/Alex
 running_process = None
 open_file_path = None
 
@@ -52,6 +55,7 @@ flask_apps = {}
 flask_logs = {}
 flask_ports = {}
 next_port = 5000
+flask_threads = {}
 
 # Get the public URL of the Gradio app
 public_url = os.environ.get("SPACE_URL", "https://huggingface.co/spaces/Devity4756/Alex-terminal")
@@ -75,11 +79,16 @@ def generate_random_name(length=12):
     return ''.join(random.choice(string.ascii_letters) for _ in range(length))
 
 def expand_path(path: str) -> str:
-    for alias, real in PATH_MAP.items():
-        if path.startswith(alias + "/"):
-            return path.replace(alias, real, 1)
+    """Expand paths relative to dataset workspace"""
+    # Handle absolute paths (relative to Alex in dataset)
     if path.startswith("/"):
-        return os.path.join(WORKDIR, path.lstrip("/"))
+        return os.path.join(VIRTUAL_HOME, path.lstrip("/"))
+    
+    # Handle virtual home alias
+    if path.startswith("Alex/"):
+        return os.path.join(VIRTUAL_HOME, path.replace("Alex/", "", 1))
+    
+    # Handle relative paths from current directory
     return os.path.join(current_dir, path)
 
 def get_local_ip():
@@ -141,14 +150,13 @@ def secure_execute_flask_code(app_instance, code, log_func, request_obj):
     random_prefix = generate_random_name(8)
     
     # Replace function definitions with randomized names
-    # This pattern matches function definitions and adds a random prefix
     code = re.sub(
         r'def (\w+)\s*\(',
         lambda m: f'def {random_prefix}_{m.group(1)}(',
         code
     )
     
-    # Create a secure environment
+    # Create a secure environment with template rendering support
     secure_globals = {
         'app': app_instance,
         'log': log_func,
@@ -157,11 +165,11 @@ def secure_execute_flask_code(app_instance, code, log_func, request_obj):
         '__builtins__': {
             'str': str, 'int': int, 'float': float, 'bool': bool, 'list': list,
             'dict': dict, 'tuple': tuple, 'set': set, 'len': len, 'range': range,
-            'print': print, 'isinstance': isinstance, 'type': type, 'repr': repr, '__import__': __import__
+            'print': print, 'isinstance': isinstance, 'type': type, 'repr': repr
         }
     }
     
-    # Add allowed Flask imports
+    # Add allowed Flask imports with template support
     try:
         from flask import Flask, request, jsonify, render_template, redirect, url_for, send_file, abort
         secure_globals.update({
@@ -186,8 +194,8 @@ def secure_execute_flask_code(app_instance, code, log_func, request_obj):
         return False, f"Execution error: {e}"
 
 def run_flask_app(app_name: str, code: str):
-    """Start a Flask app on a dedicated port"""
-    global next_port
+    """Start a Flask app using dataset paths"""
+    global next_port, current_dir
     log_buffer = io.StringIO()
     flask_logs[app_name] = log_buffer
     port = next_port
@@ -206,27 +214,55 @@ def run_flask_app(app_name: str, code: str):
             return f"Failed to start Flask app: {validation_msg}"
 
         from flask import Flask, request
-        local_flask = Flask(app_name)
-
-        @local_flask.route("/")
-        def home():
-            return f"Hello from {app_name}!<br><br>App is running successfully."
+        
+        # Get the absolute path to templates
+        template_dir = os.path.abspath(os.path.join(VIRTUAL_HOME, 'templates'))
+        static_dir = os.path.abspath(os.path.join(VIRTUAL_HOME, 'static'))
+        
+        # Create directories if they don't exist
+        os.makedirs(template_dir, exist_ok=True)
+        os.makedirs(static_dir, exist_ok=True)
+        
+        log(f"Absolute template path: {template_dir}")
+        log(f"Template dir exists: {os.path.exists(template_dir)}")
+        if os.path.exists(template_dir):
+            log(f"Files in template dir: {os.listdir(template_dir)}")
+
+        # Use absolute paths for templates and static files
+        app = Flask(
+            app_name,
+            template_folder=template_dir,
+            static_folder=static_dir,
+            static_url_path='/static'
+        )
+        
+        # Set root path to dataset Alex directory
+        app.root_path = os.path.abspath(VIRTUAL_HOME)
 
-        success, exec_msg = secure_execute_flask_code(local_flask, code, log, request)
+        success, exec_msg = secure_execute_flask_code(app, code, log, request)
         if not success:
             log(f"Failed to execute code: {exec_msg}")
             return f"Failed to start Flask app: {exec_msg}"
 
         def run_app():
             try:
-                local_flask.run(host='0.0.0.0', port=port, debug=False, use_reloader=False)
+                # Change to dataset directory using absolute path
+                original_cwd = os.getcwd()
+                abs_alex_path = os.path.abspath(VIRTUAL_HOME)
+                os.chdir(abs_alex_path)
+                
+                log(f"Running Flask from: {os.getcwd()}")
+                log(f"Template folder contents: {os.listdir(template_dir) if os.path.exists(template_dir) else 'NOT FOUND'}")
+                
+                app.run(host='0.0.0.0', port=port, debug=False, use_reloader=False)
+                
+                os.chdir(original_cwd)
             except Exception as e:
                 log(f"Error running Flask app: {e}")
-                return f"Error running Flask app: {e}"
 
         thread = threading.Thread(target=run_app, daemon=True)
         thread.start()
-        flask_apps[app_name] = local_flask
+        flask_apps[app_name] = app
 
         local_ip = get_local_ip()
         local_url = f"http://{local_ip}:{port}"
@@ -237,12 +273,27 @@ def run_flask_app(app_name: str, code: str):
             live_url = f"{public_url}/proxy/{port}/"
 
         log(f"Started Flask app: {app_name} on port {port}")
+        log(f"Absolute dataset directory: {os.path.abspath(VIRTUAL_HOME)}")
+        log(f"Absolute template folder: {template_dir}")
         log(f"Local URL: {local_url}")
         log(f"Live URL: {live_url}")
-        return f"Started Flask app: {app_name}\nLocal URL: {local_url}\nLive URL: {live_url}"
+        
+        return f"Started Flask app: {app_name}\nDataset directory: {os.path.abspath(VIRTUAL_HOME)}\nLocal URL: {local_url}\nLive URL: {live_url}"
     except Exception as e:
         log(f"Error starting Flask app {app_name}: {e}")
         return f"Error starting Flask app: {e}"
+        
+def check_template_path():
+    """Debug function to check template path"""
+    template_path = os.path.abspath(os.path.join(VIRTUAL_HOME, 'templates', 'index.html'))
+    return {
+        'template_path': template_path,
+        'exists': os.path.exists(template_path),
+        'is_file': os.path.isfile(template_path) if os.path.exists(template_path) else False,
+        'template_dir': os.path.dirname(template_path),
+        'template_dir_exists': os.path.exists(os.path.dirname(template_path)),
+        'template_dir_contents': os.listdir(os.path.dirname(template_path)) if os.path.exists(os.path.dirname(template_path)) else []
+    }        
 
 def is_flask_app(file_path):
     """Check if a Python file contains Flask code."""
@@ -287,6 +338,36 @@ def run_python_app(file_path: str):
     thread.start()
     
     return f"Started Python application: {file_path}"
+    
+def stop_flask_app(app_name: str):
+    """Stop a specific Flask app"""
+    if app_name not in flask_threads:
+        return f"Flask app '{app_name}' is not running"
+    
+    try:
+        # Try to gracefully shutdown the Flask app
+        if app_name in flask_apps:
+            # Flask doesn't have a built-in shutdown method for the dev server,
+            # so we'll rely on thread termination
+            pass
+        
+        # Terminate the thread (this is a bit forceful but works for the dev server)
+        thread = flask_threads[app_name]
+        if thread.is_alive():
+            # Note: This may not clean up perfectly since Flask's dev server
+            # doesn't have a proper shutdown mechanism
+            pass
+        
+        # Clean up the tracking dictionaries
+        flask_apps.pop(app_name, None)
+        flask_logs.pop(app_name, None)
+        flask_ports.pop(app_name, None)
+        flask_threads.pop(app_name, None)
+        
+        return f"Stopped Flask app: {app_name}"
+        
+    except Exception as e:
+        return f"Error stopping Flask app '{app_name}': {e}"
 
 def is_flask_app(file_path):
     """Check if a Python file contains Flask code."""
@@ -315,15 +396,18 @@ def get_flask_apps():
     result = "Running Flask apps:\n\n"
     
     for app_name, port in flask_ports.items():
+        thread = flask_threads.get(app_name)
+        status = "Running" if thread and thread.is_alive() else "Stopped"
         local_url = f"http://{local_ip}:{port}"
         
         if "hf.space" in public_url:
             space_id = public_url.split("https://")[1].split(".hf.space")[0]
             live_url = f"https://{space_id}.hf.space/proxy/{port}/"
-            result += f"- {app_name}:\n  Local: {local_url}\n  Live: {live_url}\n\n"
+            result += f"- {app_name} ({status}):\n  Local: {local_url}\n  Live: {live_url}\n\n"
         else:
-            result += f"- {app_name}:\n  Local: {local_url}\n  Live: {public_url}/proxy/{port}/\n\n"
+            result += f"- {app_name} ({status}):\n  Local: {local_url}\n  Live: {public_url}/proxy/{port}/\n\n"
     
+    result += "Use 'close <app_name>' to stop a specific Flask app."
     return result
 
 def run_command(cmd: str):
@@ -341,11 +425,14 @@ def run_command(cmd: str):
     try:
         # === STOP running process ===
         if raw_cmd == "close":
-            if running_process and running_process.poll() is None:
-                running_process.terminate()
-                running_process = None
-                return f"$ {cmd}\n\nStopped running process.", "", None
-            return f"$ {cmd}\n\nNo active process to stop.", "", None
+          if args:
+            result = stop_flask_app(args)
+            return f"$ {cmd}\n\n{result}", "", None
+          elif running_process and running_process.poll() is None:
+            running_process.terminate()
+            running_process = None
+            return f"$ {cmd}\n\nStopped running process.", "", None
+          return f"$ {cmd}\n\nNo active process to stop.", "", None
 
         # === Start Flask app from code ===
         elif raw_cmd == "flaskrun" and args:
@@ -380,12 +467,70 @@ def run_command(cmd: str):
         elif raw_cmd == "flasklist":
             apps_info = get_flask_apps()
             return f"$ {cmd}\n\n{apps_info}", "", None
+        # In run_command function, update debug:
+        elif raw_cmd == "debug":
+          result = f"Dataset workspace: {WORKDIR}\n"
+          result += f"Virtual home (Alex): {VIRTUAL_HOME}\n"
+          result += f"Current directory: {current_dir}\n"
+          
+          # Check template path in detail
+          template_info = check_template_path()
+          result += f"Absolute template path: {template_info['template_path']}\n"
+          result += f"Template exists: {template_info['exists']}\n"
+          result += f"Template is file: {template_info['is_file']}\n"
+          result += f"Template dir exists: {template_info['template_dir_exists']}\n"
+          result += f"Template dir contents: {template_info['template_dir_contents']}\n"
+    
+          result += f"Alex contents: {os.listdir(VIRTUAL_HOME) if os.path.exists(VIRTUAL_HOME) else 'Alex directory not found'}\n"
+          result += f"HF Token configured: {bool(HF_TOKEN)}\n"
+          return f"$ {cmd}\n\n{result}", "", None
+          
+          
+        # In run_command function, add:
+        elif raw_cmd == "sync":
+          """Sync current state with Hugging Face dataset"""
+          if not HF_TOKEN:
+            return "HF_TOKEN not configured. Cannot sync with dataset.", "", None
+    
+          try:
+            api.upload_folder(
+              folder_path=WORKDIR,
+              repo_id=DATASET_REPO,
+              repo_type="dataset",
+              commit_message=f"Manual sync: {datetime.now().isoformat()}",
+              token=HF_TOKEN
+            )
+            return "Synced workspace with Hugging Face dataset", "", None
+          except Exception as e:
+            return f"Sync failed: {e}", "", None
+            
+        # In the run_command function, add this case:
+        elif raw_cmd == "mkdir" and args:
+          if not args:
+            return f"$ {cmd}\n\nNo directory specified", "", None
+          target = expand_path(args)
+          os.makedirs(target, exist_ok=True)
+          return f"$ {cmd}\n\nCreated directory: {target}", "", None
 
         # === View logs ===
         elif raw_cmd == "logs" and args:
             app_name = args
             logs = view_logs(app_name)
             return f"$ {cmd}\n\nLogs for {app_name}:\n{logs}", "", None
+            
+        # In run_command function, add:
+        elif raw_cmd == "testtemplate":
+          """Test if template can be loaded manually"""
+          try:
+            template_path = os.path.join(VIRTUAL_HOME, 'templates', 'index.html')
+            if os.path.exists(template_path):
+              with open(template_path, 'r') as f:
+                content = f.read()
+              return f"$ {cmd}\n\nTemplate found! Content length: {len(content)} characters", "", None
+            else:
+              return f"$ {cmd}\n\nTemplate not found at: {template_path}", "", None
+          except Exception as e:
+            return f"$ {cmd}\n\nError testing template: {e}", "", None
 
         # === Change directory (cd) ===
         elif raw_cmd == "cd":
@@ -486,21 +631,23 @@ def save_file(new_content: str, file_path: str):
         with open(file_path, "w", encoding="utf-8") as f:
             f.write(new_content)
 
+        # Always sync with Hugging Face dataset
         if HF_TOKEN and api:
             try:
-                api.upload_folder(
-                    folder_path=WORKDIR,
+                # Upload the specific file that was modified
+                api.upload_file(
+                    path_or_fileobj=file_path,
+                    path_in_repo=file_path.replace(WORKDIR + "/", ""),
                     repo_id=DATASET_REPO,
                     repo_type="dataset",
-                    commit_message=f"Edited file: {file_path}",
+                    commit_message=f"Updated file: {os.path.basename(file_path)}",
                     token=HF_TOKEN
                 )
+                return f"Saved file: {file_path} (synced with dataset)", new_content
             except Exception as e:
-                print("Upload failed:", e)
+                return f"Saved file: {file_path} (local only - upload failed: {e})", new_content
         else:
-            print("Save local only - no HF token configured")
-
-        return f"Saved file: {file_path}", new_content
+            return f"Saved file: {file_path} (local only - no HF token)", new_content
     except Exception as e:
         return f"Error saving file: {e}", new_content