Update app.py

app.py

@@ -1,118 +1,75 @@
-# app.py
-from flask import Flask, request, jsonify, render_template, stream_with_context, Response
+from flask import Flask, render_template, request, jsonify, send_from_directory
 import os
-import subprocess
 import tempfile
 import shutil
-import sys
-import logging
+import subprocess
+from gtts import gTTS
 
 app = Flask(__name__)
-logging.basicConfig(level=logging.DEBUG)
 
-# Create a temporary directory for operations with full permissions
+# Temporary directory for running commands and storing files
 temp_dir = tempfile.mkdtemp()
-os.chmod(temp_dir, 0o777)
+UPLOAD_FOLDER = os.path.join(temp_dir, "uploads")
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
 
-@app.route("/")
+@app.route('/')
 def index():
-    return render_template("index.html")
+    return render_template('index.html')
+
+@app.route('/run', methods=['POST'])
+def run_command():
+    command = request.json.get("command", "").strip()
+    result = {"output": "", "error": None, "audio_file": None}
 
-def execute_shell_command(command):
-    """Executes a shell command and streams output with improved error handling."""
     try:
-        # Split the command for better security and handling
-        if command.startswith('git clone'):
-            # Special handling for git clone
-            process = subprocess.Popen(
-                command,
-                shell=True,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
+        # If the command starts with 'python', execute as Python code
+        if command.startswith("python"):
+            script_code = command.replace("python", "").strip()
+            python_file = os.path.join(temp_dir, "temp_script.py")
+            with open(python_file, "w") as f:
+                f.write(script_code)
+            process = subprocess.run(
+                ["python3", python_file], 
+                capture_output=True, 
                 text=True,
-                cwd=temp_dir,
-                env={'GIT_TERMINAL_PROMPT': '0'}  # Prevent git from prompting
+                cwd=temp_dir
             )
+            result["output"] = process.stdout
+            if process.stderr:
+                result["error"] = process.stderr
+
+        # Handle shell commands like `git clone`
         else:
-            process = subprocess.Popen(
-                command,
-                shell=True,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
+            process = subprocess.run(
+                command, 
+                shell=True, 
+                capture_output=True, 
                 text=True,
                 cwd=temp_dir
             )
+            result["output"] = process.stdout
+            if process.stderr:
+                result["error"] = process.stderr
 
-        # Stream output in real-time
-        while True:
-            output = process.stdout.readline()
-            error = process.stderr.readline()
-            
-            if output:
-                yield f"{output}<br>"
-            if error:
-                yield f"<span style='color: red'>Error: {error}</span><br>"
-            
-            # Check if process has finished
-            if output == '' and error == '' and process.poll() is not None:
-                break
-
-        # Get return code
-        return_code = process.poll()
-        if return_code != 0:
-            yield f"<span style='color: red'>Command failed with return code {return_code}</span><br>"
-        else:
-            yield "Command completed successfully.<br>"
+        # Check for generated audio file
+        for file in os.listdir(temp_dir):
+            if file.endswith(".mp3"):
+                result["audio_file"] = file
 
     except Exception as e:
-        yield f"<span style='color: red'>Error executing command: {str(e)}</span><br>"
-    finally:
-        if process:
-            process.stdout.close()
-            process.stderr.close()
+        result["error"] = str(e)
 
-@app.route("/execute", methods=["POST"])
-def execute_code():
-    command = request.json.get("code", "").strip()
-    if not command:
-        return jsonify({"result": "Error: No command provided."})
+    return jsonify(result)
 
-    try:
-        if command.startswith("!"):
-            shell_command = command[1:]
-            # Log the command being executed
-            app.logger.debug(f"Executing shell command: {shell_command}")
-            return Response(
-                stream_with_context(execute_shell_command(shell_command)),
-                content_type='text/html'
-            )
-        else:
-            # Handle Python code execution
-            process = subprocess.run(
-                [sys.executable, "-c", command],
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True,
-                cwd=temp_dir
-            )
-            return jsonify({"result": process.stdout + process.stderr})
-    except Exception as e:
-        app.logger.error(f"Error executing command: {str(e)}")
-        return jsonify({"result": f"Error: {str(e)}"})
+@app.route('/download/<filename>')
+def download_file(filename):
+    return send_from_directory(temp_dir, filename, as_attachment=True)
 
-@app.route("/cleanup", methods=["POST"])
+@app.route('/cleanup', methods=['POST'])
 def cleanup():
-    global temp_dir
-    try:
-        if os.path.exists(temp_dir):
-            shutil.rmtree(temp_dir, ignore_errors=True)
-        temp_dir = tempfile.mkdtemp()
-        os.chmod(temp_dir, 0o777)
-        return jsonify({"result": "Temporary files cleaned up."})
-    except Exception as e:
-        return jsonify({"result": f"Error during cleanup: {str(e)}"})
+    shutil.rmtree(temp_dir)
+    os.makedirs(temp_dir, exist_ok=True)
+    return jsonify({"status": "Temporary files deleted."})
 
 if __name__ == "__main__":
-    # Ensure the temp directory has proper permissions
-    os.chmod(temp_dir, 0o777)
-    app.run(host="0.0.0.0", port=7860, debug=True)
+    app.run(host="0.0.0.0", port=7860)