Update app.py

app.py

@@ -243,6 +243,189 @@ print('File written to /tmp/{filename}')
     result = execute_code(kc, code)
     return jsonify({"output": result["stdout"], "path": f"/tmp/{filename}"})
 
+    # 1. Terminal command execution
+@app.route('/terminal', methods=['POST'])
+def terminal():
+    if not check_auth(): return jsonify({"error": "Unauthorized"}), 401
+    data = request.json or {}
+    cmd = data.get("command", "")
+    session_id = data.get("session_id", "default")
+    if not cmd:
+        return jsonify({"error": "No command"}), 400
+    safe_code = f"""
+import subprocess, shlex
+result = subprocess.run(
+    shlex.split({repr(cmd)}),
+    capture_output=True, text=True, timeout=30, cwd='/tmp'
+)
+print(result.stdout)
+if result.stderr: print("STDERR:", result.stderr)
+print("Exit code:", result.returncode)
+"""
+    kc = get_or_create_kernel(session_id)
+    return jsonify(execute_code(kc, safe_code))
+
+
+# 2. File download — return file from /tmp/ as base64
+@app.route('/download', methods=['POST'])
+def download_file():
+    if not check_auth(): return jsonify({"error": "Unauthorized"}), 401
+    data = request.json or {}
+    filename = data.get("filename", "")
+    session_id = data.get("session_id", "default")
+    code = f"""
+import base64, os
+path = '/tmp/{filename}'
+if os.path.exists(path):
+    with open(path, 'rb') as f:
+        b64 = base64.b64encode(f.read()).decode()
+    print(f"FILE_B64_START:{{b64}}:FILE_B64_END")
+    print(f"Size: {{os.path.getsize(path)}} bytes")
+else:
+    print("File not found:", path)
+"""
+    kc = get_or_create_kernel(session_id)
+    result = execute_code(kc, code)
+    # Extract b64 from output
+    import re
+    m = re.search(r'FILE_B64_START:(.+?):FILE_B64_END', result.get("stdout",""))
+    if m:
+        return jsonify({"filename": filename, "base64": m.group(1), "found": True})
+    return jsonify({"found": False, "output": result.get("stdout","")})
+
+
+# 3. List /tmp files
+@app.route('/files', methods=['GET', 'POST'])
+def list_files():
+    if not check_auth(): return jsonify({"error": "Unauthorized"}), 401
+    data = (request.json or {}) if request.method == 'POST' else {}
+    session_id = data.get("session_id", "default")
+    code = """
+import os, json
+files = []
+for f in os.listdir('/tmp'):
+    path = f'/tmp/{f}'
+    if os.path.isfile(path):
+        files.append({"name": f, "size": os.path.getsize(path),
+                      "modified": os.path.getmtime(path)})
+print(json.dumps(sorted(files, key=lambda x: x['modified'], reverse=True)))
+"""
+    kc = get_or_create_kernel(session_id)
+    result = execute_code(kc, code)
+    try:
+        return jsonify({"files": __import__('json').loads(result.get("stdout","[]"))})
+    except Exception:
+        return jsonify({"files": [], "raw": result.get("stdout","")})
+
+
+# 4. Audio output endpoint
+@app.route('/audio', methods=['POST'])
+def generate_audio():
+    """Generate audio via TTS or synthesis in the kernel."""
+    if not check_auth(): return jsonify({"error": "Unauthorized"}), 401
+    data = request.json or {}
+    session_id = data.get("session_id", "default")
+    code = data.get("code", "")
+    kc = get_or_create_kernel(session_id)
+    result = execute_code(kc, code, timeout=120)
+    # Collect audio artifacts specifically
+    audio_artifacts = [a for a in result.get("artifacts", [])
+                       if a.get("type","").startswith("audio/")]
+    return jsonify({**result, "audio_artifacts": audio_artifacts})
+
+
+# 5. Browser actions endpoint (structured)
+@app.route('/browser', methods=['POST'])
+def browser_action():
+    """
+    Execute structured browser actions without raw code.
+    action: screenshot | navigate | click | type | extract | pdf
+    """
+    if not check_auth(): return jsonify({"error": "Unauthorized"}), 401
+    data = request.json or {}
+    action = data.get("action", "screenshot")
+    url = data.get("url", "")
+    session_id = data.get("session_id", "browser")
+
+    if action == "screenshot":
+        code = f"""
+from playwright.sync_api import sync_playwright
+with sync_playwright() as p:
+    browser = p.chromium.launch(args=['--no-sandbox'])
+    page = browser.new_page(viewport={{'width':1280,'height':720}})
+    page.goto('{url}', wait_until='networkidle', timeout=30000)
+    screenshot = page.screenshot(full_page={data.get('full_page', False)})
+    title = page.title()
+    browser.close()
+import IPython.display as d
+d.display(d.Image(data=screenshot))
+print(f"URL: {url}")
+print(f"Title: {{title}}")
+"""
+    elif action == "extract":
+        selector = data.get("selector", "body")
+        code = f"""
+from playwright.sync_api import sync_playwright
+with sync_playwright() as p:
+    browser = p.chromium.launch(args=['--no-sandbox'])
+    page = browser.new_page()
+    page.goto('{url}', wait_until='networkidle', timeout=30000)
+    text = page.inner_text('{selector}')
+    browser.close()
+print(text[:5000])
+"""
+    elif action == "pdf":
+        code = f"""
+from playwright.sync_api import sync_playwright
+with sync_playwright() as p:
+    browser = p.chromium.launch(args=['--no-sandbox'])
+    page = browser.new_page()
+    page.goto('{url}', wait_until='networkidle', timeout=30000)
+    pdf_bytes = page.pdf(format='A4')
+    browser.close()
+import base64
+print("PDF_B64:" + base64.b64encode(pdf_bytes).decode())
+print(f"PDF size: {{len(pdf_bytes)}} bytes")
+"""
+    else:
+        return jsonify({"error": f"Unknown action: {action}"}), 400
+
+    kc = get_or_create_kernel(session_id)
+    return jsonify(execute_code(kc, code, timeout=60))
+
+
+# 6. Health endpoint with capabilities list
+@app.route('/capabilities')
+def capabilities():
+    return jsonify({
+        "python":     True,
+        "playwright": True,
+        "packages": [
+            "pandas","numpy","matplotlib","seaborn","scipy","plotly",
+            "requests","beautifulsoup4","pillow","openpyxl",
+            "PyPDF2","python-docx","fpdf2","reportlab","kaleido"
+        ],
+        "endpoints": [
+            "/execute","/install","/upload","/download",
+            "/terminal","/files","/browser","/audio",
+            "/sessions","/capabilities"
+        ]
+    })
+
+
+# 7. Interrupt running kernel (for long loops)
+@app.route('/interrupt/<session_id>', methods=['POST'])
+def interrupt_kernel(session_id):
+    if not check_auth(): return jsonify({"error": "Unauthorized"}), 401
+    with sessions_lock:
+        if session_id not in sessions:
+            return jsonify({"error": "Session not found"}), 404
+        try:
+            sessions[session_id]["km"].interrupt_kernel()
+            return jsonify({"message": f"Kernel {session_id} interrupted"})
+        except Exception as e:
+            return jsonify({"error": str(e)}), 500
+
 if __name__ == "__main__":
     print("[SANDBOX] Pre-warming default kernel...")
     get_or_create_kernel("default")