Update app.py

app.py

@@ -40,6 +40,55 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
+# Check if sudo is available on the system
+def is_sudo_available():
+    """Check if sudo command is available on the system"""
+    if platform.system() == "Windows":
+        return False  # Windows doesn't use sudo
+    
+    try:
+        result = subprocess.run(
+            ["which", "sudo"],
+            capture_output=True,
+            text=True,
+            check=False
+        )
+        return result.returncode == 0
+    except Exception:
+        return False
+
+# Try to use sudo if available, with password prompt if needed
+def run_with_sudo(command, password=None):
+    """Run a command with sudo if available, with optional password"""
+    if not is_sudo_available():
+        # Fall back to running without sudo
+        return subprocess.run(command, capture_output=True, text=True)
+    
+    # Prepare sudo command
+    sudo_cmd = ["sudo", "-S"] + command
+    
+    try:
+        if password:
+            # Run with provided password
+            process = subprocess.Popen(
+                sudo_cmd,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True
+            )
+            stdout, stderr = process.communicate(input=password + "\n")
+            return subprocess.CompletedProcess(
+                sudo_cmd, process.returncode, stdout, stderr
+            )
+        else:
+            # Run without password (relies on cached sudo credentials)
+            return subprocess.run(sudo_cmd, capture_output=True, text=True)
+    except Exception as e:
+        logger.error(f"Error running sudo command: {str(e)}")
+        # Fall back to running without sudo
+        return subprocess.run(command, capture_output=True, text=True)
+
 # Model configuration mapping for different API requirements and limits
 MODEL_CONFIGS = {
     "DeepSeek-V3-0324": {"max_tokens": 4000, "param_name": "max_tokens", "api_version": None, "category": "DeepSeek", "warning": None},
@@ -115,7 +164,9 @@ def check_password():
         return False
     return True
 
+# Enhanced package management
 def ensure_packages():
+    """Install required packages with sudo if available"""
     required_packages = {
         'manim': '0.17.3',
         'Pillow': '9.0.0',
@@ -124,19 +175,109 @@ def ensure_packages():
         'torch': '2.0.0',
         'pygments': '2.15.1',
         'streamlit-ace': '0.1.1',
-        'pydub': '0.25.1',  # For audio processing
-        'plotly': '5.14.0',  # For timeline editor
-        'pandas': '2.0.0',   # For data manipulation
-        'python-pptx': '0.6.21',  # For PowerPoint export
-        'markdown': '3.4.3',  # For markdown processing
-        'fpdf': '1.7.2',     # For PDF generation
-        'matplotlib': '3.5.0',  # For Python script runner
-        'seaborn': '0.11.2',  # For enhanced visualizations
-        'scipy': '1.7.3',    # For scientific computations
-        'huggingface_hub': '0.16.0',  # For Hugging Face API
+        'pydub': '0.25.1',
+        'plotly': '5.14.0',
+        'pandas': '2.0.0',
+        'python-pptx': '0.6.21',
+        'markdown': '3.4.3',
+        'fpdf': '1.7.2',
+        'matplotlib': '3.5.0',
+        'seaborn': '0.11.2',
+        'scipy': '1.7.3',
+        'huggingface_hub': '0.16.0',
+        'azure-ai-inference': '1.0.0b9',
+        'azure-core': '1.33.0',
+        'openai': '1.0.0'
     }
     
-    with st.spinner("Checking required packages..."):
+    # System dependencies for manim (Ubuntu/Debian-based systems)
+    system_dependencies = [
+        "libcairo2-dev",
+        "pkg-config",
+        "python3-dev",
+        "libpango1.0-dev",
+        "ffmpeg",
+        "texlive-latex-recommended",
+        "texlive-fonts-recommended",
+        "texlive-latex-extra",
+        "fonts-dejavu-core",
+        "libsndfile1"
+    ]
+    
+    with st.spinner("Checking and installing system dependencies..."):
+        # Check if we're on a system that uses apt
+        apt_available = False
+        try:
+            result = subprocess.run(
+                ["which", "apt-get"],
+                capture_output=True,
+                text=True,
+                check=False
+            )
+            apt_available = result.returncode == 0
+        except Exception:
+            apt_available = False
+        
+        if apt_available:
+            # Install system dependencies
+            progress_bar = st.progress(0)
+            status_text = st.empty()
+            
+            # Update apt
+            status_text.text("Updating package lists...")
+            try:
+                # First try with sudo
+                sudo_password = None
+                if is_sudo_available():
+                    sudo_password = st.text_input("Enter sudo password for system package installation:", type="password")
+                    if sudo_password:
+                        run_with_sudo(["apt-get", "update"], sudo_password)
+                    else:
+                        # Try without password (cached sudo credentials)
+                        run_with_sudo(["apt-get", "update"])
+                else:
+                    # Try without sudo
+                    subprocess.run(["apt-get", "update"], capture_output=True)
+            except Exception as e:
+                logger.warning(f"Error updating apt: {str(e)}")
+            
+            # Install each dependency
+            for i, package in enumerate(system_dependencies):
+                progress = (i / len(system_dependencies))
+                progress_bar.progress(progress)
+                status_text.text(f"Installing system dependency: {package}...")
+                
+                try:
+                    # Try with sudo
+                    if is_sudo_available() and sudo_password:
+                        result = run_with_sudo(
+                            ["apt-get", "install", "-y", package],
+                            sudo_password
+                        )
+                    else:
+                        # Try without sudo
+                        result = subprocess.run(
+                            ["apt-get", "install", "-y", package],
+                            capture_output=True,
+                            text=True
+                        )
+                    
+                    if result.returncode != 0:
+                        logger.warning(f"Could not install system package {package}: {result.stderr}")
+                except Exception as e:
+                    logger.warning(f"Error installing system package {package}: {str(e)}")
+            
+            progress_bar.progress(1.0)
+            status_text.text("System dependencies installation complete!")
+            time.sleep(0.5)
+            progress_bar.empty()
+            status_text.empty()
+        else:
+            # If not on an apt-based system, show message
+            st.warning("System dependencies may need to be installed manually. See the documentation for details.")
+    
+    # Check and install Python packages
+    with st.spinner("Checking required Python packages..."):
         # First, quickly check if packages are already installed
         missing_packages = {}
         for package, version in required_packages.items():
@@ -177,29 +318,69 @@ def ensure_packages():
                     import scipy
                 elif package == 'huggingface_hub':
                     import huggingface_hub
+                elif package == 'azure-ai-inference':
+                    import azure.ai.inference
+                elif package == 'azure-core':
+                    import azure.core
+                elif package == 'openai':
+                    import openai
             except ImportError:
                 missing_packages[package] = version
         
         # If no packages are missing, return success immediately
         if not missing_packages:
-            logger.info("All required packages already installed.")
+            logger.info("All required Python packages already installed.")
             return True
         
         # If there are missing packages, install them with progress reporting
         progress_bar = st.progress(0)
         status_text = st.empty()
         
+        # Check if pip install requires sudo
+        pip_requires_sudo = False
+        try:
+            # Try to write to site-packages
+            import site
+            site_packages = site.getsitepackages()[0]
+            # Check if we have write access
+            test_file = os.path.join(site_packages, "test_write_access.txt")
+            try:
+                with open(test_file, "w") as f:
+                    f.write("test")
+                os.remove(test_file)
+            except (PermissionError, OSError):
+                pip_requires_sudo = True
+        except Exception:
+            # If anything goes wrong, assume we might need sudo
+            pip_requires_sudo = True
+        
+        # Ask for sudo password if needed
+        sudo_password = None
+        if pip_requires_sudo and is_sudo_available():
+            sudo_password = st.text_input("Enter sudo password for Python package installation:", type="password")
+        
         for i, (package, version) in enumerate(missing_packages.items()):
             try:
                 progress = (i / len(missing_packages))
                 progress_bar.progress(progress)
                 status_text.text(f"Installing {package}...")
                 
-                result = subprocess.run(
-                    [sys.executable, "-m", "pip", "install", f"{package}>={version}"], 
-                    capture_output=True, 
-                    text=True
-                )
+                pip_install_cmd = [sys.executable, "-m", "pip", "install", f"{package}>={version}"]
+                
+                if pip_requires_sudo and is_sudo_available():
+                    # Use sudo for pip install
+                    if sudo_password:
+                        result = run_with_sudo(pip_install_cmd, sudo_password)
+                    else:
+                        # Try without password (cached sudo credentials)
+                        result = run_with_sudo(pip_install_cmd)
+                else:
+                    # Use normal pip install
+                    result = subprocess.run(
+                        pip_install_cmd, 
+                        capture_output=True, 
+                        text=True
+                    )
                 
                 if result.returncode != 0:
                     st.error(f"Failed to install {package}: {result.stderr}")
@@ -212,14 +393,14 @@ def ensure_packages():
                 return False
         
         progress_bar.progress(1.0)
-        status_text.text("All packages installed successfully!")
+        status_text.text("All Python packages installed successfully!")
         time.sleep(0.5)
         progress_bar.empty()
         status_text.empty()
         return True
 
 def install_custom_packages(package_list):
-    """Install custom packages specified by the user without page refresh"""
+    """Install custom packages specified by the user with sudo if needed"""
     if not package_list.strip():
         return True, "No packages specified"
     
@@ -232,6 +413,29 @@ def install_custom_packages(package_list):
     status_placeholder = st.sidebar.empty()
     progress_bar = st.sidebar.progress(0)
     
+    # Check if pip install requires sudo
+    pip_requires_sudo = False
+    try:
+        # Try to write to site-packages
+        import site
+        site_packages = site.getsitepackages()[0]
+        # Check if we have write access
+        test_file = os.path.join(site_packages, "test_write_access.txt")
+        try:
+            with open(test_file, "w") as f:
+                f.write("test")
+            os.remove(test_file)
+        except (PermissionError, OSError):
+            pip_requires_sudo = True
+    except Exception:
+        # If anything goes wrong, assume we might need sudo
+        pip_requires_sudo = True
+    
+    # Ask for sudo password if needed
+    sudo_password = None
+    if pip_requires_sudo and is_sudo_available():
+        sudo_password = st.text_input("Enter sudo password for custom package installation:", type="password")
+    
     results = []
     success = True
     
@@ -241,11 +445,22 @@ def install_custom_packages(package_list):
             progress_bar.progress(progress)
             status_placeholder.text(f"Installing {package}...")
             
-            result = subprocess.run(
-                [sys.executable, "-m", "pip", "install", package], 
-                capture_output=True, 
-                text=True
-            )
+            pip_install_cmd = [sys.executable, "-m", "pip", "install", package]
+            
+            if pip_requires_sudo and is_sudo_available():
+                # Use sudo for pip install
+                if sudo_password:
+                    result = run_with_sudo(pip_install_cmd, sudo_password)
+                else:
+                    # Try without password (cached sudo credentials)
+                    result = run_with_sudo(pip_install_cmd)
+            else:
+                # Use normal pip install
+                result = subprocess.run(
+                    pip_install_cmd, 
+                    capture_output=True, 
+                    text=True
+                )
             
             if result.returncode != 0:
                 error_msg = f"Failed to install {package}: {result.stderr}"
@@ -270,6 +485,267 @@ def install_custom_packages(package_list):
     
     return success, "\n".join(results)
 
+# Install C/C++ libraries with sudo if needed
+def install_cpp_libraries(libraries):
+    """Install C/C++ libraries using system package manager with sudo if needed"""
+    if not libraries:
+        return True, "No libraries specified"
+    
+    # Library to package mappings for different systems
+    library_packages = {
+        "Ubuntu": {
+            "Eigen": ["libeigen3-dev"],
+            "Boost": ["libboost-all-dev"],
+            "OpenCV": ["libopencv-dev", "python3-opencv"],
+            "FFTW": ["libfftw3-dev"],
+            "SDL2": ["libsdl2-dev"],
+            "SFML": ["libsfml-dev"],
+            "OpenGL": ["libgl1-mesa-dev", "libglu1-mesa-dev", "freeglut3-dev"]
+        },
+        "Debian": {
+            "Eigen": ["libeigen3-dev"],
+            "Boost": ["libboost-all-dev"],
+            "OpenCV": ["libopencv-dev", "python3-opencv"],
+            "FFTW": ["libfftw3-dev"],
+            "SDL2": ["libsdl2-dev"],
+            "SFML": ["libsfml-dev"],
+            "OpenGL": ["libgl1-mesa-dev", "libglu1-mesa-dev", "freeglut3-dev"]
+        },
+        "Fedora": {
+            "Eigen": ["eigen3-devel"],
+            "Boost": ["boost-devel"],
+            "OpenCV": ["opencv-devel", "python3-opencv"],
+            "FFTW": ["fftw-devel"],
+            "SDL2": ["SDL2-devel"],
+            "SFML": ["SFML-devel"],
+            "OpenGL": ["mesa-libGL-devel", "mesa-libGLU-devel", "freeglut-devel"]
+        },
+        "CentOS": {
+            "Eigen": ["eigen3-devel"],
+            "Boost": ["boost-devel"],
+            "OpenCV": ["opencv-devel"],
+            "FFTW": ["fftw-devel"],
+            "SDL2": ["SDL2-devel"],
+            "SFML": ["SFML-devel"],
+            "OpenGL": ["mesa-libGL-devel", "mesa-libGLU-devel", "freeglut-devel"]
+        },
+        "Arch": {
+            "Eigen": ["eigen"],
+            "Boost": ["boost"],
+            "OpenCV": ["opencv"],
+            "FFTW": ["fftw"],
+            "SDL2": ["sdl2"],
+            "SFML": ["sfml"],
+            "OpenGL": ["mesa", "glu", "freeglut"]
+        },
+        "MacOS": {
+            "Eigen": ["eigen"],
+            "Boost": ["boost"],
+            "OpenCV": ["opencv"],
+            "FFTW": ["fftw"],
+            "SDL2": ["sdl2"],
+            "SFML": ["sfml"],
+            "OpenGL": ["mesa", "freeglut"]
+        }
+    }
+    
+    # Detect OS
+    os_name = "Unknown"
+    package_manager = None
+    install_cmd = []
+    
+    if platform.system() == "Linux":
+        # Try to detect Linux distribution
+        try:
+            if os.path.exists("/etc/os-release"):
+                with open("/etc/os-release", "r") as f:
+                    os_release = f.read()
+                    if "Ubuntu" in os_release:
+                        os_name = "Ubuntu"
+                        package_manager = "apt-get"
+                        install_cmd = ["apt-get", "install", "-y"]
+                    elif "Debian" in os_release:
+                        os_name = "Debian"
+                        package_manager = "apt-get"
+                        install_cmd = ["apt-get", "install", "-y"]
+                    elif "Fedora" in os_release:
+                        os_name = "Fedora"
+                        package_manager = "dnf"
+                        install_cmd = ["dnf", "install", "-y"]
+                    elif "CentOS" in os_release:
+                        os_name = "CentOS"
+                        package_manager = "yum"
+                        install_cmd = ["yum", "install", "-y"]
+                    elif "Arch" in os_release:
+                        os_name = "Arch"
+                        package_manager = "pacman"
+                        install_cmd = ["pacman", "-S", "--noconfirm"]
+            
+            # Fallback detection
+            if os_name == "Unknown":
+                which_apt = subprocess.run(["which", "apt-get"], capture_output=True, text=True)
+                which_dnf = subprocess.run(["which", "dnf"], capture_output=True, text=True)
+                which_yum = subprocess.run(["which", "yum"], capture_output=True, text=True)
+                which_pacman = subprocess.run(["which", "pacman"], capture_output=True, text=True)
+                
+                if which_apt.returncode == 0:
+                    os_name = "Debian"
+                    package_manager = "apt-get"
+                    install_cmd = ["apt-get", "install", "-y"]
+                elif which_dnf.returncode == 0:
+                    os_name = "Fedora"
+                    package_manager = "dnf"
+                    install_cmd = ["dnf", "install", "-y"]
+                elif which_yum.returncode == 0:
+                    os_name = "CentOS"
+                    package_manager = "yum"
+                    install_cmd = ["yum", "install", "-y"]
+                elif which_pacman.returncode == 0:
+                    os_name = "Arch"
+                    package_manager = "pacman"
+                    install_cmd = ["pacman", "-S", "--noconfirm"]
+        except Exception as e:
+            logger.error(f"Error detecting Linux distribution: {str(e)}")
+    
+    elif platform.system() == "Darwin":
+        os_name = "MacOS"
+        which_brew = subprocess.run(["which", "brew"], capture_output=True, text=True)
+        if which_brew.returncode == 0:
+            package_manager = "brew"
+            install_cmd = ["brew", "install"]
+    
+    # If package manager not detected, return error
+    if not package_manager:
+        return False, f"Could not detect package manager for {platform.system()}. Please install libraries manually."
+    
+    # Get packages to install
+    all_packages = []
+    for library in libraries:
+        if os_name in library_packages and library in library_packages[os_name]:
+            all_packages.extend(library_packages[os_name][library])
+    
+    if not all_packages:
+        return False, f"No packages found for the selected libraries on {os_name}. Please install libraries manually."
+    
+    # Display progress
+    status_placeholder = st.sidebar.empty()
+    progress_bar = st.sidebar.progress(0)
+    
+    # Ask for sudo password if needed (most package managers need sudo)
+    sudo_password = None
+    if is_sudo_available() and platform.system() != "Darwin":  # macOS Homebrew doesn't need sudo
+        sudo_password = st.text_input("Enter sudo password for C/C++ library installation:", type="password")
+    
+    results = []
+    success = True
+    
+    # Update package lists if needed
+    if package_manager in ["apt-get", "apt"]:
+        status_placeholder.text("Updating package lists...")
+        try:
+            if is_sudo_available() and sudo_password:
+                result = run_with_sudo(["apt-get", "update"], sudo_password)
+            elif is_sudo_available():
+                result = run_with_sudo(["apt-get", "update"])
+            else:
+                result = subprocess.run(["apt-get", "update"], capture_output=True, text=True)
+            
+            if result.returncode != 0:
+                logger.warning(f"Failed to update package lists: {result.stderr}")
+                results.append(f"Warning: Failed to update package lists: {result.stderr}")
+        except Exception as e:
+            logger.warning(f"Error updating package lists: {str(e)}")
+            results.append(f"Warning: Error updating package lists: {str(e)}")
+    
+    # Install each package
+    for i, package in enumerate(all_packages):
+        try:
+            progress = (i / len(all_packages))
+            progress_bar.progress(progress)
+            status_placeholder.text(f"Installing {package}...")
+            
+            cmd = install_cmd + [package]
+            
+            if is_sudo_available() and platform.system() != "Darwin":  # macOS Homebrew doesn't need sudo
+                if sudo_password:
+                    result = run_with_sudo(cmd, sudo_password)
+                else:
+                    result = run_with_sudo(cmd)
+            else:
+                result = subprocess.run(cmd, capture_output=True, text=True)
+            
+            if result.returncode != 0:
+                error_msg = f"Failed to install {package}: {result.stderr}"
+                results.append(error_msg)
+                logger.error(error_msg)
+                success = False
+            else:
+                results.append(f"Successfully installed {package}")
+                logger.info(f"Successfully installed C/C++ library package: {package}")
+                
+        except Exception as e:
+            error_msg = f"Error installing {package}: {str(e)}"
+            results.append(error_msg)
+            logger.error(error_msg)
+            success = False
+    
+    progress_bar.progress(1.0)
+    status_placeholder.text("Installation complete!")
+    time.sleep(0.5)
+    progress_bar.empty()
+    status_placeholder.empty()
+    
+    return success, "\n".join(results)
+
+# Auto-detect C/C++ libraries
+def detect_cpp_libraries():
+    """Auto-detect installed C/C++ libraries on the system"""
+    libraries = {}
+    
+    # Function to check if a library is installed
+    def check_library(name, headers, pkg_config=None):
+        # Check if headers exist
+        header_found = False
+        for header in headers:
+            # Common include directories
+            include_dirs = [
+                "/usr/include",
+                "/usr/local/include",
+                "/opt/local/include",
+                "/opt/homebrew/include"
+            ]
+            
+            for include_dir in include_dirs:
+                if os.path.exists(os.path.join(include_dir, header)):
+                    header_found = True
+                    break
+        
+        # Check using pkg-config if available
+        pkg_config_found = False
+        if pkg_config:
+            try:
+                result = subprocess.run(
+                    ["pkg-config", "--exists", pkg_config],
+                    capture_output=True,
+                    check=False
+                )
+                pkg_config_found = result.returncode == 0
+            except Exception:
+                pass
+        
+        return header_found or pkg_config_found
+    
+    # Check for common libraries
+    libraries["Eigen"] = check_library("Eigen", ["Eigen/Core", "eigen3/Eigen/Core"])
+    libraries["Boost"] = check_library("Boost", ["boost/config.hpp", "boost/version.hpp"])
+    libraries["OpenCV"] = check_library("OpenCV", ["opencv2/opencv.hpp"], "opencv4")
+    libraries["FFTW"] = check_library("FFTW", ["fftw3.h"], "fftw3")
+    libraries["SDL2"] = check_library("SDL2", ["SDL2/SDL.h"], "sdl2")
+    libraries["SFML"] = check_library("SFML", ["SFML/Graphics.hpp"], "sfml-all")
+    libraries["OpenGL"] = check_library("OpenGL", ["GL/gl.h", "OpenGL/gl.h"])
+    
+    return libraries
+
 @st.cache_resource(ttl=3600)
 def init_ai_models_direct():
     """Direct implementation using the exact pattern from the example code"""
@@ -822,8 +1298,6 @@ def generate_manim_video(python_code, format_type, quality_preset, animation_spe
         # IMPORTANT: Wait a moment for file system to catch up
         time.sleep(3)
         
-        # Rest of the function remains the same
-        
         # Special handling for GIF format - if Manim failed to generate a GIF but we have an MP4
         if format_type == "gif" and (not output_file_path or not os.path.exists(output_file_path)) and mp4_output_path and os.path.exists(mp4_output_path):
             status_placeholder.info("GIF generation via Manim failed. Trying FFmpeg conversion...")
@@ -1509,6 +1983,42 @@ def compile_cpp_code_enhanced(code, settings, project_files=None, enable_debug=F
         if enable_debug:
             compile_cmd.append("-g")
         
+        # Auto-detect include paths if not specified
+        include_paths = settings.get("include_paths", [])
+        if not include_paths:
+            # Common include directories
+            common_include_dirs = [
+                "/usr/include",
+                "/usr/local/include",
+                "/opt/local/include",
+                "/opt/homebrew/include"
+            ]
+            
+            # Add detected paths for specified libraries
+            for lib in settings.get("libraries", []):
+                if lib == "Eigen":
+                    for dir in common_include_dirs:
+                        if os.path.exists(os.path.join(dir, "Eigen")):
+                            include_paths.append(dir)
+                        elif os.path.exists(os.path.join(dir, "eigen3")):
+                            include_paths.append(dir)
+                elif lib == "OpenCV":
+                    try:
+                        # Get OpenCV include paths using pkg-config
+                        result = subprocess.run(
+                            ["pkg-config", "--cflags", "opencv4"],
+                            capture_output=True,
+                            text=True,
+                            check=False
+                        )
+                        if result.returncode == 0:
+                            # Extract include paths from pkg-config output
+                            for flag in result.stdout.strip().split():
+                                if flag.startswith("-I"):
+                                    include_paths.append(flag[2:])
+                    except Exception:
+                        pass
+        
         # Add preprocessor definitions
         for definition in settings.get("definitions", []):
             if "=" in definition:
@@ -1518,7 +2028,7 @@ def compile_cpp_code_enhanced(code, settings, project_files=None, enable_debug=F
                 compile_cmd.append(f"-D{definition}")
         
         # Add include paths
-        for path in settings.get("include_paths", []):
+        for path in include_paths:
             compile_cmd.append(f"-I{path}")
         
         # Add library paths
@@ -2517,6 +3027,153 @@ int main() {
             with st.expander("Installation Results"):
                 st.code(st.session_state.custom_library_result)
                 
+        # System Package Management section
+        with st.sidebar.expander("🛠️ System Package Management"):
+            st.markdown("## System Dependencies")
+            st.markdown("Manage system packages and libraries")
+            
+            # Auto-detect C/C++ libraries
+            if st.button("Detect Installed Libraries", key="detect_system_libs"):
+                with st.spinner("Detecting installed libraries..."):
+                    libraries = detect_cpp_libraries()
+                    
+                    # Display results
+                    st.markdown("### Detected Libraries")
+                    for lib, installed in libraries.items():
+                        if installed:
+                            st.success(f"✅ {lib}: Installed")
+                        else:
+                            st.warning(f"⚠️ {lib}: Not detected")
+            
+            # Install C/C++ libraries
+            st.markdown("### Install C/C++ Libraries")
+            cpp_libs_to_install = st.multiselect(
+                "Select libraries to install",
+                options=["Eigen", "Boost", "OpenCV", "FFTW", "SDL2", "SFML", "OpenGL"],
+                default=[]
+            )
+            
+            if st.button("Install Selected Libraries", key="install_cpp_libs"):
+                success, result = install_cpp_libraries(cpp_libs_to_install)
+                if success:
+                    st.success("Libraries installed successfully!")
+                else:
+                    st.error("Failed to install some libraries")
+                st.code(result)
+            
+            # System package installation
+            st.markdown("### Install System Packages")
+            system_packages = st.text_area(
+                "Enter system packages to install (comma separated)",
+                placeholder="e.g., ffmpeg, git, cmake"
+            )
+            
+            if st.button("Install System Packages", key="install_system_packages"):
+                if not system_packages.strip():
+                    st.warning("No packages specified")
+                else:
+                    packages = [pkg.strip() for pkg in system_packages.split(',') if pkg.strip()]
+                    
+                    # Detect package manager
+                    package_manager = None
+                    install_cmd = []
+                    
+                    if platform.system() == "Linux":
+                        which_apt = subprocess.run(["which", "apt-get"], capture_output=True, text=True)
+                        which_dnf = subprocess.run(["which", "dnf"], capture_output=True, text=True)
+                        which_yum = subprocess.run(["which", "yum"], capture_output=True, text=True)
+                        which_pacman = subprocess.run(["which", "pacman"], capture_output=True, text=True)
+                        
+                        if which_apt.returncode == 0:
+                            package_manager = "apt-get"
+                            install_cmd = ["apt-get", "install", "-y"]
+                        elif which_dnf.returncode == 0:
+                            package_manager = "dnf"
+                            install_cmd = ["dnf", "install", "-y"]
+                        elif which_yum.returncode == 0:
+                            package_manager = "yum"
+                            install_cmd = ["yum", "install", "-y"]
+                        elif which_pacman.returncode == 0:
+                            package_manager = "pacman"
+                            install_cmd = ["pacman", "-S", "--noconfirm"]
+                    
+                    elif platform.system() == "Darwin":
+                        which_brew = subprocess.run(["which", "brew"], capture_output=True, text=True)
+                        if which_brew.returncode == 0:
+                            package_manager = "brew"
+                            install_cmd = ["brew", "install"]
+                    
+                    if not package_manager:
+                        st.error(f"Could not detect package manager for {platform.system()}. Please install packages manually.")
+                    else:
+                        # Ask for sudo password if needed
+                        sudo_password = None
+                        if is_sudo_available() and platform.system() != "Darwin":  # macOS Homebrew doesn't need sudo
+                            sudo_password = st.text_input("Enter sudo password for system package installation:", type="password")
+                        
+                        # Update package lists if needed
+                        if package_manager in ["apt-get", "apt"]:
+                            with st.spinner("Updating package lists..."):
+                                try:
+                                    if is_sudo_available() and sudo_password:
+                                        result = run_with_sudo(["apt-get", "update"], sudo_password)
+                                    elif is_sudo_available():
+                                        result = run_with_sudo(["apt-get", "update"])
+                                    else:
+                                        result = subprocess.run(["apt-get", "update"], capture_output=True, text=True)
+                                    
+                                    if result.returncode != 0:
+                                        st.warning(f"Failed to update package lists: {result.stderr}")
+                                except Exception as e:
+                                    st.warning(f"Error updating package lists: {str(e)}")
+                        
+                        # Install packages
+                        results = []
+                        success = True
+                        
+                        progress_bar = st.sidebar.progress(0)
+                        status_text = st.sidebar.empty()
+                        
+                        for i, package in enumerate(packages):
+                            try:
+                                progress = (i / len(packages))
+                                progress_bar.progress(progress)
+                                status_text.text(f"Installing {package}...")
+                                
+                                cmd = install_cmd + [package]
+                                
+                                if is_sudo_available() and platform.system() != "Darwin":  # macOS Homebrew doesn't need sudo
+                                    if sudo_password:
+                                        result = run_with_sudo(cmd, sudo_password)
+                                    else:
+                                        result = run_with_sudo(cmd)
+                                else:
+                                    result = subprocess.run(cmd, capture_output=True, text=True)
+                                
+                                if result.returncode != 0:
+                                    error_msg = f"Failed to install {package}: {result.stderr}"
+                                    results.append(error_msg)
+                                    success = False
+                                else:
+                                    results.append(f"Successfully installed {package}")
+                                    
+                            except Exception as e:
+                                error_msg = f"Error installing {package}: {str(e)}"
+                                results.append(error_msg)
+                                success = False
+                        
+                        progress_bar.progress(1.0)
+                        time.sleep(0.5)
+                        progress_bar.empty()
+                        status_text.empty()
+                        
+                        if success:
+                            st.success("All packages installed successfully!")
+                        else:
+                            st.error("Failed to install some packages")
+                        
+                        st.code("\n".join(results))
+                
         # C/C++ Library Options
         with st.sidebar.expander("C/C++ Library Options"):
             st.markdown("### Advanced C/C++ Settings")