Update streamlit_app.py

streamlit_app.py

@@ -2,251 +2,242 @@ import streamlit as st
 import subprocess
 import os
 import logging
-import json
-import requests
-from streamlit.components.v1 import html
+import threading
+import time
+from huggingface_hub import snapshot_download
 
 # Configure logging
-logging.basicConfig(filename='supercoder_launcher.log', level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logging.basicConfig(
+    filename='supercoder_launcher.log',
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
 
-# Define repository and project directories
+# Directories
 REPO_DIR = os.path.join(os.getcwd(), "SuperCoder")
-PROJECT_DIR = os.getcwd()
 
-# Create requirements.txt
-def create_requirements_txt():
-    requirements_content = "streamlit\n"
-    try:
-        with open(os.path.join(REPO_DIR, 'requirements.txt'), 'w') as f:
-            f.write(requirements_content.strip())
-        logging.info("requirements.txt created successfully.")
-    except Exception as e:
-        logging.error(f"Error creating requirements.txt: {str(e)}")
-
-# Create Dockerfile
-def create_dockerfile():
-    dockerfile_content = """
-FROM python:3.9-slim
-WORKDIR /app
-# Install git
-RUN apt-get update && apt-get install -y git
-# Copy requirements first to leverage Docker cache
-COPY requirements.txt .
-RUN pip install -r requirements.txt
-# Copy the rest of the application
-COPY . .
-# Expose the Streamlit port
-EXPOSE 8501
-# Health check to ensure the container is running properly
-HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 CMD curl -f http://localhost:8501/_stcore/health || exit 1
-# Command to run the application
-ENTRYPOINT ["streamlit", "run", "app.py", "--server.address", "0.0.0.0"]
-"""
-    try:
-        with open(os.path.join(REPO_DIR, 'Dockerfile'), 'w') as f:
-            f.write(dockerfile_content.strip())
-        logging.info("Dockerfile created successfully.")
-    except Exception as e:
-        logging.error(f"Error creating Dockerfile: {str(e)}")
-
-# Function to handle Hugging Face models, datasets, and spaces
-def handle_huggingface_request(link, instruction):
-    # Example logic for handling Hugging Face models, datasets, and spaces
-    if "huggingface.co" in link:
-        # Process the link based on the type (model, dataset, space)
-        if "models" in link:
-            # Logic to deploy or modify a model
-            logging.info(f"Processing Hugging Face model: {link}")
-            # Add your model handling logic here
-        elif "datasets" in link:
-            # Logic to parse or combine datasets
-            logging.info(f"Processing Hugging Face dataset: {link}")
-            # Add your dataset handling logic here
-        elif "spaces" in link:
-            # Logic to modify and deploy a space
-            logging.info(f"Processing Hugging Face space: {link}")
-            # Add your space handling logic here
-    elif "github.com" in link:
-        # Logic to handle GitHub repositories
-        logging.info(f"Processing GitHub repository: {link}")
-        # Add your GitHub handling logic here
-    else:
-        logging.warning(f"Unsupported link: {link}")
-
-# Streamlit app interface
-def main():
-    st.set_page_config(page_title="SuperCoder Launcher", page_icon="🚀")
-    st.title("🚀 SuperCoder Launcher")
-    st.markdown("""
-    This application helps you set up and run SuperCoder.
-    Follow the steps below to get started.
-    """)
-
-    # Initialize session state
-    if 'setup_complete' not in st.session_state:
-        st.session_state.setup_complete = False
-    if 'install_complete' not in st.session_state:
-        st.session_state.install_complete = False
-    if 'terminal_output' not in st.session_state:
-        st.session_state.terminal_output = []
+# Session state initialization
+if 'terminal_output' not in st.session_state:
+    st.session_state.terminal_output = []
+if 'setup_complete' not in st.session_state:
+    st.session_state.setup_complete = False
+if 'running' not in st.session_state:
+    st.session_state.running = False
+
+# ---------- Utility functions ----------
+def log_terminal(line: str):
+    st.session_state.terminal_output.append(line)
+    logging.info(line)
 
-    terminal_container = st.empty()
+def clear_terminal():
+    st.session_state.terminal_output = []
 
-    def update_terminal(output):
-        st.session_state.terminal_output.append(output)
-        terminal_container.code('\n'.join(st.session_state.terminal_output))
+def get_command_output(command: str, cwd: str = None) -> str:
+    try:
+        result = subprocess.run(
+            command, shell=True, cwd=cwd, capture_output=True, text=True, timeout=60
+        )
+        return result.stdout + "\n" + result.stderr
+    except Exception as e:
+        return f"Error executing command: {str(e)}"
 
-    # Function to execute shell commands
-    def execute_command(command: str, cwd: str = None) -> bool:
+def run_command_background(command: str, cwd: str = None):
+    log_terminal(f"> {command}")
+    def target():
         try:
             process = subprocess.Popen(
-                command,
-                shell=True,
-                cwd=cwd,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True
+                command, shell=True, cwd=cwd,
+                stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+                text=True, bufsize=1, universal_newlines=True
             )
-            
-            while True:
-                output = process.stdout.readline()
-                if output == '' and process.poll() is not None:
-                    break
-                if output:
-                    update_terminal(output.strip())
-                    logging.info(output.strip())
-                
-            stderr = process.stderr.read()
-            if stderr:
-                update_terminal(f"Error: {stderr.strip()}")
-                logging.error(stderr.strip())
-                
-            return process.poll() == 0
+            for line in process:
+                if line:
+                    log_terminal(line.rstrip())
+            returncode = process.wait()
+            log_terminal(f"Process finished with return code: {returncode}")
         except Exception as e:
-            update_terminal(f"Error executing command: {str(e)}")
-            logging.error(f"Error executing command: {str(e)}")
-            return False
-
-    # Input fields for Hugging Face models, datasets, spaces, and GitHub links
-    st.subheader("Input Links")
-    huggingface_link = st.text_input("Hugging Face Model/Dataset/Space Link")
-    github_link = st.text_input("GitHub Repository Link")
-    instruction = st.text_area("Instructions for Processing")
-
-    if st.button("Submit"):
-        if huggingface_link or github_link:
-            if huggingface_link:
-                handle_huggingface_request(huggingface_link, instruction)
-            if github_link:
-                handle_huggingface_request(github_link, instruction)
-            st.success("Request processed. Check terminal for details.")
-        else:
-            st.error("Please provide at least one link.")
+            log_terminal(f"Exception in background command: {str(e)}")
+    threading.Thread(target=target, daemon=True).start()
+    st.success("Command started in background. Refresh terminal to see progress.")
+
+# Hugging Face handling (enhanced)
+def handle_huggingface(link: str, instruction: str, hf_token: str = None):
+    log_terminal(f"Processing Hugging Face link: {link}")
+    log_terminal(f"Instruction: {instruction}")
+    if "spaces" in link:
+        parts = link.split("huggingface.co/spaces/")[-1].strip("/")
+        clone_url = f"https://huggingface.co/spaces/{parts}"
+        if hf_token:
+            clone_url = f"https:{hf_token}@huggingface.co/spaces/{parts}"
+        dir_name = parts.split("/")[-1]
+        cmd = f"git clone {clone_url} workspaces/{dir_name}"
+        run_command_background(cmd, cwd=REPO_DIR)
+    elif "datasets" in link or "models" in link:
+        repo_id = link.split("huggingface.co/")[-1].strip("/")
+        local_dir = os.path.join(REPO_DIR, "models", repo_id.split("/")[-1])
+        try:
+            path = snapshot_download(
+                repo_id=repo_id,
+                local_dir=local_dir,
+                token=hf_token or None,
+                ignore_patterns=["*.bin"] if "small" in instruction.lower() else None
+            )
+            log_terminal(f"Downloaded {repo_id} → {path}")
+        except Exception as e:
+            log_terminal(f"HF download error: {str(e)}")
+    else:
+        log_terminal("Unsupported Hugging Face link type.")
+
+# ---------- Main UI ----------
+st.set_page_config(page_title="SuperCoder Advanced Launcher", page_icon="🚀", layout="wide")
+st.title("🚀 SuperCoder Advanced Launcher")
+st.markdown("Full-featured launcher for [TransformerOptimus/SuperCoder](https://github.com/TransformerOptimus/SuperCoder) with Docker Compose, .env config, live logs, preview, and Hugging Face/GitHub integrations.")
 
-    # Setup steps
-    with st.expander("1. Clone Repository", expanded=not st.session_state.setup_complete):
-        if st.button("Clone SuperCoder"):
+tabs = st.tabs(["Setup", "Config", "Run", "Logs & Status", "Preview", "Integrations", "Terminal"])
+
+with tabs[0]:  # Setup
+    st.subheader("Repository Management")
+    repo_git = os.path.join(REPO_DIR, ".git")
+    cloned = os.path.isdir(repo_git)
+
+    if not cloned:
+        if st.button("Clone SuperCoder Repository", type="primary"):
             with st.spinner("Cloning repository..."):
-                if os.path.exists(REPO_DIR):
-                    update_terminal("Repository already exists. Skipping clone.")
-                    logging.info("Repository already exists. Skipping clone.")
+                cmd = f"git clone https://github.com/TransformerOptimus/SuperCoder {REPO_DIR}"
+                success = subprocess.run(cmd, shell=True, capture_output=True, text=True).returncode == 0
+                if success:
+                    st.session_state.setup_complete = True
+                    st.success("Repository cloned successfully.")
+                    st.rerun()
                 else:
-                    success = execute_command(
-                        "git clone https://github.com/TransformerOptimus/SuperCoder",
-                        PROJECT_DIR
-                    )
-                    if success:
-                        create_requirements_txt()
-                        create_dockerfile()
-                        st.session_state.setup_complete = True
-                        st.success("Repository cloned successfully.")
-                    else:
-                        st.error("Failed to clone the repository. Check logs for details.")
-
-    with st.expander("2. Build and Run Docker Container", expanded=st.session_state.setup_complete and not st.session_state.install_complete):
-        if st.button("Build and Run Container", disabled=not st.session_state.setup_complete):
-            with st.spinner("Building and running Docker container..."):
-                # Build Docker image
-                build_success = execute_command(
-                    "docker build -t supercoder .",
-                    REPO_DIR
-                )
-                
-                if build_success:
-                    # Run Docker container
-                    run_success = execute_command(
-                        "docker run -d -p 8501:8501 --name supercoder_container supercoder",
-                        REPO_DIR
-                    )
-                    
-                    if run_success:
-                        st.session_state.install_complete = True
-                        st.success("Docker container is running!")
-                    else:
-                        st.error("Failed to run the Docker container. Check logs for details.")
-                else:
-                    st.error("Failed to build the Docker image. Check logs for details.")
-
-    with st.expander("3. Access Application", expanded=st.session_state.install_complete):
-        if st.session_state.install_complete:
-            st.markdown("""
-            The application is running! Access it at:
-            
-            [http://localhost:8501](http://localhost:8501)
-            """)
-            
-            if st.button("Stop Container"):
-                execute_command("docker stop supercoder_container")
-                execute_command("docker rm supercoder_container")
-                st.session_state.install_complete = False
-                st.success("Docker container stopped and removed.")
-
-    # Display terminal output
-    st.markdown("### Terminal Output")
-    terminal_container.code('\n'.join(st.session_state.terminal_output))
-
-    # Add a clear terminal button
-    if st.button("Clear Terminal"):
-        st.session_state.terminal_output = []
-        st.success("Terminal cleared.")
-
-    # Add a reset button
-    if st.button("Reset Setup"):
-        if st.session_state.install_complete:
-            execute_command("docker stop supercoder_container")
-            execute_command("docker rm supercoder_container")
+                    st.error("Clone failed. Check logs.")
+    else:
+        st.success("✅ Repository cloned")
+        st.session_state.setup_complete = True
+        if st.button("Update Repository (git pull)"):
+            with st.spinner("Pulling latest changes..."):
+                run_command_background("git pull", cwd=REPO_DIR)
+
+with tabs[1]:  # Config
+    st.subheader(".env Configuration (API keys, etc.)")
+    env_path = os.path.join(REPO_DIR, ".env")
+    default_env = """OPENAI_API_KEY=sk-...
+ANTHROPIC_API_KEY=...
+HF_TOKEN=hf_...
+# Add other keys as needed
+"""
+    if os.path.exists(env_path):
+        with open(env_path) as f:
+            env_content = f.read()
+    else:
+        env_content = default_env
+
+    new_env = st.text_area(".env content", value=env_content, height=400)
+    if st.button("Save .env"):
+        try:
+            with open(env_path, "w") as f:
+                f.write(new_env)
+            st.success(".env saved successfully.")
+        except Exception as e:
+            st.error(f"Save failed: {e}")
+
+with tabs[2]:  # Run
+    st.subheader("Docker Compose Controls")
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        if st.button("Start / Rebuild", type="primary", disabled=not st.session_state.setup_complete):
+            run_command_background("docker compose up --build -d", cwd=REPO_DIR)
+            st.session_state.running = True
+    with col2:
+        if st.button("Stop"):
+            run_command_background("docker compose down", cwd=REPO_DIR)
+            st.session_state.running = False
+    with col3:
+        if st.button("Restart"):
+            run_command_background("docker compose restart", cwd=REPO_DIR)
+
+    if st.button("Full Rebuild (down + up --build)"):
+        run_command_background("docker compose down && docker compose up --build -d", cwd=REPO_DIR)
+
+with tabs[3]:  # Logs & Status
+    st.subheader("Service Status & Logs")
+    auto = st.checkbox("Auto-refresh every 8 seconds")
+    if auto:
+        st.autorefresh(interval=8000, key="logsrefresh")
+
+    c1, c2 = st.columns(2)
+    with c1:
+        st.markdown("**docker compose ps**")
+        status = get_command_output("docker compose ps", cwd=REPO_DIR)
+        st.code(status)
+    with c2:
+        st.markdown("**Recent logs**")
+        logs = get_command_output("docker compose logs --tail=1000", cwd=REPO_DIR)
+        st.code(logs, language="log")
+
+with tabs[4]:  # Preview
+    st.subheader("Live Application Preview")
+    if st.session_state.running or "Up" in get_command_output("docker compose ps -q", cwd=REPO_DIR):
+        st.components.v1.iframe("http://localhost:3000", height=900, scrolling=True)
+    else:
+        st.warning("Application not running. Start it in the Run tab first.")
+
+with tabs[5]:  # Integrations
+    st.subheader("Hugging Face & GitHub Integrations")
+    hf_token = st.text_input("Hugging Face Token (for private repos)", type="password")
+    link = st.text_input("Hugging Face or GitHub Link")
+    instruction = st.text_area("Instructions (e.g., 'small model only', path hints)")
+    if st.button("Process Link"):
+        if not link:
+            st.error("Provide a link.")
+        else:
+            if "huggingface.co" in link:
+                handle_huggingface(link, instruction, hf_token)
+            elif "github.com" in link:
+                dir_name = link.split("/")[-1].replace(".git", "")
+                cmd = f"git clone {link} workspaces/{dir_name}"
+                run_command_background(cmd, cwd=REPO_DIR)
+            st.success("Processing started.")
+
+    st.markdown("---")
+    st.subheader("Manual HF Model/Dataset Download")
+    repo_id = st.text_input("Repo ID (e.g. meta-llama/Llama-3-8B)")
+    target_dir = st.text_input("Target subdirectory (relative to SuperCoder)", default="models/custom")
+    if st.button("Download Now"):
+        full_path = os.path.join(REPO_DIR, target_dir)
+        os.makedirs(full_path, exist_ok=True)
+        try:
+            snapshot_download(repo_id=repo_id, local_dir=full_path, token=hf_token or None)
+            st.success(f"Downloaded to {full_path}")
+        except Exception as e:
+            st.error(str(e))
+
+with tabs[6]:  # Terminal
+    st.subheader("Command Output Terminal")
+    st.code("\n".join(st.session_state.terminal_output), language="bash")
+    col1, col2 = st.columns(2)
+    with col1:
+        if st.button("Refresh Terminal"):
+            st.rerun()
+    with col2:
+        if st.button("Clear Terminal"):
+            clear_terminal()
+            st.rerun()
+
+st.sidebar.markdown("### Quick Actions")
+if st.sidebar.button("Full Reset (stop + remove repo)"):
+    if st.sidebar.checkbox("Confirm dangerous action"):
+        run_command_background("docker compose down -v", cwd=REPO_DIR)
+        if os.path.exists(REPO_DIR):
+            import shutil
+            shutil.rmtree(REPO_DIR)
         st.session_state.setup_complete = False
-        st.session_state.install_complete = False
-        st.session_state.terminal_output = []
-        st.success("Setup reset.")
-
-    # Embed an interactive terminal
-    terminal_html = """
-    <div id="terminal" style="width: 100%; height: 400px; border: 1px solid black;"></div>
-    <script>
-        var term = new Terminal();
-        var fitAddon = new Fit Addon.FitAddon();
-        term.loadAddon(fitAddon);
-        term.open(document.getElementById('terminal'));
-        fitAddon.fit();
-        term.onData(function(data) {
-            // Send data to Python backend
-            var xhr = new XMLHttpRequest();
-            xhr.open("POST", "/send_data", true);
-            xhr.setRequestHeader("Content-Type", "application/json;charset=UTF-8");
-            xhr.send(JSON.stringify({data: data}));
-        });
-        // Receive data from Python backend
-        window.addEventListener('message', function(event) {
-            var message = event.data;
-            if (message.type === 'terminal_output') {
-                term.write(message.output);
-            }
-        });
-    </script>
-    """
-
-    html(terminal_html, height=400)
-
-if __name__ == "__main__":
-    main()
+        st.session_state.running = False
+        clear_terminal()
+        st.success("Reset complete.")
+
+st.sidebar.markdown("---")
+st.sidebar.caption(f"Launcher running from: {os.getcwd()}")
+st.sidebar.caption("SuperCoder directory: ./SuperCoder")
+
+Status: CONVERGED ✅