Upload 26 files

README.md

@@ -1,12 +1,141 @@
+# FastHost
+
+✨ **FastHost** is an open-source, self-hosted deployment platform for Python backend apps. Think of it as your own Vercel or Replit, but tailored for FastAPI and Flask using Docker.
+
+With FastHost, you can upload a `.py` file or project archive and instantly deploy it as a running Docker container on your own machine. It’s perfect for developers, tinkerers, and teams who want full control over their Python backend deployments—no third-party cloud required.
+
 ---
-title: Fasthost
-emoji: 🔥
-colorFrom: purple
-colorTo: pink
-sdk: docker
-pinned: false
-license: apache-2.0
-short_description: fasthost
----
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+🚧 **FastHost is in active development!**  
+We welcome contributions, feedback, and ideas from the community. If you’d like to help shape FastHost, check out the issues, open a pull request, or start a discussion.
+
+#Roadmap:
+Phase 1: Core Deployment & Developer Experience (MVP)
+Goal: Establish a stable and user-friendly platform for deploying FastAPI/Flask applications via Git, with essential management tools.
+
+1.1 Git-based Deployments (High Priority):
+
+Feature: Implement integration with Git providers (GitHub, GitLab, Bitbucket) to allow users to connect repositories.
+
+Value: Automates deployments on git push, significantly improving developer workflow and replacing manual zip uploads.
+
+Implementation: Webhooks from Git providers, repository cloning, branch selection for deployment.
+
+1.2 Automated SSL/TLS with Custom Domains (High Priority):
+
+Feature: Allow users to add custom domains and automatically provision/renew SSL certificates using Let's Encrypt.
+
+Value: Essential for production-ready applications, building trust, and a professional appearance.
+
+Implementation: DNS validation (e.g., CNAME/TXT record instructions), ACME client integration.
+
+1.3 Environment Variables Management:
+
+Feature: A secure UI for users to define, update, and manage environment variables for their deployed applications.
+
+Value: Separates configuration from code, crucial for different environments (dev, staging, prod) and sensitive data.
+
+Implementation: Encrypted storage of variables, injection into Docker builds/containers.
+
+1.4 Real-time Build & Deployment Logs:
+
+Feature: Stream stdout/stderr from the build process (Docker build, dependencies installation) and deployment steps directly to the user interface.
+
+Value: Provides transparency, enabling users to debug issues during the deployment cycle.
+
+Implementation: WebSockets or SSE for log streaming.
+
+1.5 Basic User Authentication & Project Management:
+
+Feature: Implement a secure user registration and login system. Allow users to create and manage their deployment projects.
+
+Value: Enables multi-user access and organization within the self-hosted instance.
+
+Implementation: Database for users/projects, secure password hashing, session management.
+
+Phase 2: Reliability, Observability & Scalability
+Goal: Enhance the platform's stability, provide critical insights into running applications, and lay the groundwork for horizontal scaling.
+
+2.1 Application Logging & Monitoring Dashboard:
+
+Feature: Centralized access to logs generated by the running FastAPI/Flask applications (e.g., from main.py). Implement basic metrics (CPU, memory, request counts).
+
+Value: Indispensable for debugging live applications, identifying performance bottlenecks, and understanding usage patterns.
+
+Implementation: Log aggregation (e.g., filebeat, fluentd, or direct container logs), Prometheus/Grafana or simpler in-house graphing.
+
+2.2 Deployment Rollbacks:
+
+Feature: Allow users to revert a deployed application to any previous successful deployment version.
+
+Value: A critical safety net for recovering quickly from bad deployments or unintended side effects.
+
+Implementation: Maintain historical Docker image references/tags for each deployment.
+
+2.3 Horizontal Scaling (Basic):
+
+Feature: Enable users to define and run multiple instances of a single application.
+
+Value: Improves application availability and performance under increased load.
+
+Implementation: Integrate with NGINX (or similar) as a load balancer to distribute traffic to multiple Docker containers/instances. UI to adjust instance count.
+
+2.4 Improved Error Handling & Notifications:
+
+Feature: Clear, actionable error messages in the UI for failed builds/deployments. Implement email or webhook notifications for critical events.
+
+Value: Reduces user frustration and keeps them informed about the status of their deployments.
+
+Phase 3: Advanced Features & Ecosystem Expansion
+Goal: Differentiate the platform with powerful capabilities, offering greater flexibility and catering to more complex use cases.
+
+3.1 Persistent Storage Integration:
+
+Feature: Provide options for attaching persistent storage volumes to applications for data that needs to survive deployments (e.g., user uploads, database files).
+
+Value: Enables stateful applications, broadening the types of projects the platform can host.
+
+Implementation: Docker volumes, bind mounts, or integration with network storage solutions if applicable to the underlying infrastructure.
+
+3.2 Custom Buildpacks/Build Steps:
+
+Feature: Allow users to define more custom build processes beyond just a Dockerfile, perhaps through a platform.yml or similar configuration.
+
+Value: Offers greater flexibility for non-standard build requirements or specialized runtimes.
+
+Implementation: Extend the build orchestration to support custom scripts or logic.
+
+3.3 Serverless Function (Python) Support:
+
+Feature: Enable users to deploy individual Python functions as serverless endpoints without managing a full application server.
+
+Value: Caters to microservices architectures, background tasks, and event-driven workloads, similar to AWS Lambda or Google Cloud Functions.
+
+Implementation: Custom runtime environment for functions, API Gateway integration.
+
+3.4 CLI Tool:
+
+Feature: Develop a command-line interface (CLI) for interacting with the platform (deploying, checking status, viewing logs).
+
+Value: Appeals to developers who prefer terminal-based workflows, enabling scripting and automation.
+
+Implementation: Python CLI with API calls to your platform's backend.
+
+3.5 Webhooks for Deployment Events:
+
+Feature: Allow users to configure webhooks that trigger on deployment success, failure, or other lifecycle events.
+
+Value: Enables integration with external services (e.g., Slack notifications, CI/CD pipelines).
+
+3.6 Comprehensive Documentation & Community:
+
+Feature: Create extensive documentation covering setup, usage, troubleshooting, and API. Foster a community around the open-source project.
+
+Value: Crucial for adoption and self-sufficiency, reducing support burden.
+
+**Contribute:**  
+- Fork the repository  
+- Create a feature branch  
+- Submit a pull request
+
+Let’s build the future of Python app deployment together!

app.py

@@ -1,7 +1,77 @@
-from fastapi import FastAPI
+from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse
+from fastapi.templating import Jinja2Templates
+import docker
+import dotenv
+from routers.deploy import router as deploy_router, deployed_projects
+from routers.controls import router as controls_router
+from routers.logs import router as logs_router
+
+# Load environment variables
+dotenv.load_dotenv()
 
 app = FastAPI()
 
-@app.get("/")
-def greet_json():
-    return {"Hello": "World!"}
+# --- Templating ---
+templates = Jinja2Templates(directory="templates")
+
+# --- Routers ---
+app.include_router(controls_router, prefix="/controls")
+app.include_router(logs_router, prefix="/logs")
+app.include_router(deploy_router, prefix="/deploy")
+
+# --- Docker Client ---
+client = docker.from_env()
+
+# --- Endpoints ---
+@app.get("/", response_class=HTMLResponse)
+async def dashboard(request: Request):
+    """Serves the main dashboard page."""
+    return templates.TemplateResponse("dashboard.html", {"request": request})
+
+@app.get("/projects")
+def get_projects():
+    """Returns a list of all deployed projects with their status and URL."""
+    
+    # Create a list of projects from the deployed_projects dictionary
+    projects_list = []
+    for project_id, details in deployed_projects.items():
+        container_name = details.get("container_name", "N/A")
+        public_url = details.get("public_url", "#")
+        local_url = "#"
+        
+        if container_name != "N/A":
+            try:
+                container = client.containers.get(container_name)
+                port_bindings = client.api.inspect_container(container.id)['NetworkSettings']['Ports']
+                if '8080/tcp' in port_bindings and port_bindings['8080/tcp'] is not None:
+                    host_port = port_bindings['8080/tcp'][0]['HostPort']
+                    # Get the local IP address of the machine
+                    import socket
+                    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+                    try:
+                        # Doesn't matter if the host is reachable
+                        s.connect(('10.255.255.255', 1))
+                        host_ip = s.getsockname()[0]
+                    except Exception:
+                        host_ip = '127.0.0.1' # Fallback to localhost
+                    finally:
+                        s.close()
+                    local_url = f"http://{host_ip}:{host_port}"
+            except docker.errors.NotFound:
+                print(f"Container {container_name} not found for project {project_id}.")
+            except Exception as e:
+                print(f"Error getting local URL for container {container_name}: {e}")
+
+        projects_list.append({
+            "id": project_id,
+            "name": details.get("app_name", "N/A"),
+            "status": details.get("status", "Unknown"),
+            "public_url": public_url,
+            "local_url": local_url,
+            "container_name": container_name
+        })
+    
+    return projects_list
+
+

examples/fastapi/Dockerfile

@@ -0,0 +1,10 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY . /app
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8080"]
+

examples/fastapi/main.py

@@ -0,0 +1,20 @@
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+import os
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/echo/{name}")
+def echo(name: str):
+    return JSONResponse(content={"message": f"Hello, {name}!"})

examples/fastapi/requirements.txt

@@ -0,0 +1,3 @@
+FastAPI
+uvicorn
+jinja2

examples/flask/Dockerfile

@@ -0,0 +1,10 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY . /app
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+CMD ["gunicorn", "main:app", "--bind", "0.0.0.0:8080"]
+

examples/flask/main.py

@@ -0,0 +1,14 @@
+from flask import Flask
+from flask_cors import CORS
+
+
+app = Flask(__name__)
+CORS(app)
+
+@app.route('/')
+def index():
+    return "Welcome to the Flask app!"
+
+@app.route('/hello')
+def hello():
+    return "Hello, World!"

examples/flask/requirements.txt

@@ -0,0 +1,3 @@
+flask
+flask_cors
+gunicorn

examples/test/Dockerfile

@@ -0,0 +1,9 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY . /app
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8080"]

examples/test/encrypt.py

@@ -0,0 +1,16 @@
+import base64
+
+SECRET_KEY = b"my-simple-key"  # Keep this key short and secret
+
+def xor_encrypt(data: bytes, key: bytes) -> bytes:
+    return bytes([b ^ key[i % len(key)] for i, b in enumerate(data)])
+
+def encrypt_video_id(video_id: str) -> str:
+    encrypted = xor_encrypt(video_id.encode(), SECRET_KEY)
+    return base64.urlsafe_b64encode(encrypted).decode().rstrip("=")
+
+def decrypt_video_id(enc_id: str) -> str:
+    padded = enc_id + "=" * (-len(enc_id) % 4)  # Add padding back
+    encrypted = base64.urlsafe_b64decode(padded.encode())
+    decrypted = xor_encrypt(encrypted, SECRET_KEY)
+    return decrypted.decode()

examples/test/main.py

@@ -0,0 +1,172 @@
+from fastapi import FastAPI, HTTPException, Request, Query, Response
+from fastapi.responses import StreamingResponse, HTMLResponse
+from fastapi.templating import Jinja2Templates
+from pytubefix import YouTube
+from pytubefix.cli import on_progress
+import os
+import logging
+import httpx
+import hashlib
+from functools import lru_cache
+from encrypt import encrypt_video_id, decrypt_video_id
+
+app = FastAPI()
+
+CHUNK_SIZE = 1024 * 1024  # 1MB
+
+logger = logging.getLogger(__name__)
+
+def open_file_range(file_path: str, start: int, end: int):
+    with open(file_path, "rb") as f:
+        f.seek(start)
+        bytes_to_read = end - start + 1
+        while bytes_to_read > 0:
+            chunk = f.read(min(CHUNK_SIZE, bytes_to_read))
+            if not chunk:
+                break
+            bytes_to_read -= len(chunk)
+            yield chunk
+
+
+def generate_etag(file_path):
+    hasher = hashlib.md5()
+    with open(file_path, 'rb') as f:
+        while chunk := f.read(8192):
+            hasher.update(chunk)
+    return hasher.hexdigest()
+
+
+@lru_cache(maxsize=128)
+def get_video_metadata(video_id: str):
+    yt = YouTube(f"https://www.youtube.com/watch?v={video_id}", client='WEB_EMBED')
+    if yt.length >= 600:
+        return {
+            "title": yt.title,
+            "description": yt.description,
+            "author": yt.author,
+            "duration": yt.length,
+            "views": yt.views,
+            "date": yt.publish_date,
+            "video_url": yt.streams.get_highest_resolution().url,
+            "audio_url": yt.streams.get_audio_only().url,
+        }
+    else:
+        return {
+            "title": yt.title,
+            "description": yt.description,
+            "author": yt.author,
+            "duration": yt.length,
+            "views": yt.views,
+            "date": yt.publish_date,
+        }
+
+
+@app.get("/api/video/{video_id}")
+def get_video_info(video_id: str, request: Request):
+    try:
+        metadata = get_video_metadata(video_id)
+        encrypted_video_id = encrypt_video_id(video_id)
+
+        BASE_URL = request.base_url
+
+        if metadata['duration'] >= 600:
+            return {**metadata}
+        else:
+            return {
+                **metadata,
+                "video_url": f"{BASE_URL}video/{encrypted_video_id}",
+                "audio_url": f"{BASE_URL}audio/{encrypted_video_id}"
+            }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")
+
+
+@app.get("/video/{video_id}")
+async def stream_video(video_id: str, request: Request, download: bool = Query(False)):
+    try:
+        decrypted_video_id = decrypt_video_id(video_id)
+        yt = YouTube(f"https://www.youtube.com/watch?v={decrypted_video_id}")
+        stream = yt.streams.get_highest_resolution()
+        url = stream.url
+
+        headers = {}
+        if range_header := request.headers.get("range"):
+            headers["Range"] = range_header
+
+        async def proxy_stream():
+            try:
+                async with httpx.AsyncClient() as client:
+                    async with client.stream("GET", url, headers=headers, timeout=60) as response:
+                        if response.status_code not in (200, 206):
+                            logger.error(f"Failed to stream: {response.status_code}")
+                            return
+                        async for chunk in response.aiter_bytes(CHUNK_SIZE):
+                            yield chunk
+            except Exception as e:
+                logger.error(f"Streaming error: {str(e)}")
+                return
+
+        response_headers = {
+            "Accept-Ranges": "bytes",
+            "Cache-Control": "public, max-age=3600"
+        }
+
+        # Handle filename safely
+        title = yt.title.encode("utf-8", "ignore").decode("utf-8")
+        if download:
+            response_headers["Content-Disposition"] = f'attachment; filename="{title}.mp4"'
+        else:
+            response_headers["Content-Disposition"] = f'inline; filename="{title}.mp4"'
+
+        return StreamingResponse(
+            proxy_stream(),
+            media_type="video/mp4",
+            headers=response_headers
+        )
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Could not fetch video URL: {str(e)}")
+
+@app.get("/audio/{video_id}")
+async def stream_audio(video_id: str, request: Request, download: bool = Query(False)):
+    try:
+        decrypted_video_id = decrypt_video_id(video_id)
+        yt = YouTube(f"https://www.youtube.com/watch?v={decrypted_video_id}")
+        stream = yt.streams.get_audio_only()
+        url = stream.url
+
+        headers = {
+            "User-Agent": request.headers.get("user-agent", "Mozilla/5.0"),
+        }
+        if range_header := request.headers.get("range"):
+            headers["Range"] = range_header
+
+        async def proxy_stream():
+            async with httpx.AsyncClient(follow_redirects=True) as client:
+                async with client.stream("GET", url, headers=headers) as response:
+                    if response.status_code not in (200, 206):
+                        raise HTTPException(status_code=502, detail="Source stream error")
+                    async for chunk in response.aiter_bytes(CHUNK_SIZE):
+                        yield chunk
+
+        response_headers = {
+            "Accept-Ranges": "bytes",
+            "Cache-Control": "public, max-age=3600"
+        }
+
+        # Handle filename safely
+        title = yt.title.encode("utf-8", "ignore").decode("utf-8")
+        if download:
+            response_headers["Content-Disposition"] = f'attachment; filename="{title}.mp3"'
+        else:
+            response_headers["Content-Disposition"] = f'inline; filename="{title}.mp3"'
+
+        return StreamingResponse(
+            proxy_stream(),
+            media_type=stream.mime_type or "audio/mp4",
+            headers=response_headers
+        )
+
+    except Exception as e:
+        logger.error(f"Streaming error: {e}")
+        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")

examples/test/requirements.txt

@@ -0,0 +1,6 @@
+fastapi
+uvicorn[standard]
+pytubefix
+httpx
+jinja2
+cryptography

project.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b5470cebe77d2a9c10b64850108e237040fac72c4519aa8a28e54bfc24fc64d6
+size 2498

requirements.txt

@@ -1,2 +1,7 @@
-fastapi
-uvicorn[standard]
+docker 
+FastAPI
+uvicorn
+pyngrok
+jinja2
+requests
+python-dotenv

routers/controls.py

@@ -0,0 +1,36 @@
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import JSONResponse, HTMLResponse
+import docker
+from docker import client
+
+router = APIRouter()
+
+docker_client = docker.from_env()
+
+@router.get("/start/{container_name}")
+def start_container(container_name: str):
+    try:
+        container = client.containers.get(container_name)
+        container.unpause()
+        return JSONResponse({"status": "started"})
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)
+
+@router.get("/pause/{container_name}")
+def pause_container(container_name: str):
+    try:
+        container = client.containers.get(container_name)
+        container.pause()
+        return JSONResponse({"status": "paused"})
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)
+
+@router.get("/stop/{container_name}")
+def stop_container(container_name: str):
+    try:
+        container = client.containers.get(container_name)
+        container.stop()
+        container.remove(force=True)
+        return JSONResponse({"status": "stopped and removed"})
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)

routers/deploy.py

@@ -0,0 +1,446 @@
+# Standard library imports
+import os
+import uuid
+import time
+import zipfile # Still imported, but primarily for handling potential old zip logic or error messages
+
+# Third-party library imports
+import docker # For interacting with Docker daemon
+import git # For Git repository operations (requires 'GitPython' package: pip install GitPython)
+import hmac # For validating GitHub webhook signatures (important for security)
+import hashlib # For hashing in webhook signature validation
+from pyngrok import ngrok # For creating public URLs (ensure ngrok is configured)
+from fastapi import APIRouter, HTTPException, UploadFile, Form, Request, BackgroundTasks # Added Request and BackgroundTasks
+from fastapi.responses import JSONResponse
+
+# Initialize FastAPI router
+router = APIRouter()
+
+deployed_projects = {}
+
+
+GITHUB_WEBHOOK_SECRET = os.getenv("GITHUB_WEBHOOK_SECRET", "your_github_webhook_secret_here_CHANGE_THIS")
+if GITHUB_WEBHOOK_SECRET == "your_github_webhook_secret_here_CHANGE_THIS":
+    print("WARNING: GITHUB_WEBHOOK_SECRET is not set. Webhook security is compromised.")
+
+# --- Helper Functions ---
+
+# Function to recursively find a file (case-insensitive) within a directory
+def _find_file_in_project(filename: str, root_dir: str) -> str | None:
+    """
+    Searches for a file (case-insensitive) within the given root directory and its subdirectories.
+    Returns the absolute path to the file if found, otherwise None.
+    """
+    filename_lower = filename.lower()
+    for dirpath, _, files in os.walk(root_dir):
+        for file in files:
+            if file.lower() == filename_lower:
+                return os.path.join(dirpath, file)
+    return None
+
+# Function to build and deploy a Docker container from a project path
+async def _build_and_deploy(project_id: str, project_path: str, app_name: str, existing_container_name: str = None):
+    """
+    Handles the Docker build and deployment process for a given project.
+    If an existing_container_name is provided, it attempts to stop and remove it first.
+    Manages ngrok tunnels for the deployed application.
+    """
+    docker_client = docker.from_env()
+
+    # Define consistent naming for Docker image and container
+    image_name = f"{app_name.lower()}_{project_id[:8]}"
+    container_name = f"{image_name}_container"
+
+    try:
+        # Step 1: Clean up old containers and images if they exist
+        # Stop and remove the previously deployed container for this project
+        if existing_container_name:
+            print(f"Attempting to stop and remove existing container: {existing_container_name}")
+            try:
+                old_container = docker_client.containers.get(existing_container_name)
+                old_container.stop(timeout=5) # Give 5 seconds to stop gracefully
+                old_container.remove(force=True)
+                print(f"Successfully stopped and removed old container: {existing_container_name}")
+            except docker.errors.NotFound:
+                print(f"Existing container {existing_container_name} not found, proceeding with new deployment.")
+            except Exception as e:
+                print(f"Error stopping/removing old container {existing_container_name}: {e}")
+
+        # Remove any exited or created containers that might be lingering from previous runs
+        # (This is a general cleanup, not specific to this project_id, but good practice)
+        for c in docker_client.containers.list(all=True):
+            if c.status in ["created", "exited"]: # Only remove non-running containers
+                # Be cautious: only remove containers clearly associated with this deployment logic
+                # For more robust logic, might check labels or names more strictly
+                if c.name.startswith(f"{app_name.lower()}_{project_id[:8]}") or c.name.startswith(f"ngrok-"):
+                    print(f"Removing leftover container {c.name} ({c.id}) with status {c.status}")
+                    try:
+                        c.remove(force=True)
+                    except Exception as e:
+                        print(f"Error removing leftover container {c.name}: {e}")
+
+        # Step 2: Build Docker image
+        print(f"Building Docker image from {project_path} with tag: {image_name}")
+        image, build_logs_generator = docker_client.images.build(path=project_path, tag=image_name, rm=True)
+        # Process build logs (can be streamed to UI in a real application)
+        for log_line in build_logs_generator:
+            if 'stream' in log_line:
+                print(f"[BUILD LOG] {log_line['stream'].strip()}")
+            elif 'error' in log_line:
+                print(f"[BUILD ERROR] {log_line['error'].strip()}")
+
+        print(f"Docker image built successfully: {image.id}")
+
+        # Step 3: Run new Docker container
+        print(f"Running new container {container_name} from image {image_name}")
+        container = docker_client.containers.run(
+            image=image_name,
+            ports={"8080/tcp": None}, # Docker will assign a random host port for 8080/tcp
+            name=container_name,
+            detach=True, # Run in background
+            mem_limit="512m", # Limit memory usage
+            nano_cpus=1_000_000_000, # Limit CPU usage to 1 full core (1 billion nano-CPUs)
+            read_only=True, # Make container filesystem read-only (except tmpfs)
+            tmpfs={"/tmp": ""}, # Mount an in-memory tmpfs for /tmp directory
+            user="1001:1001" # Run as a non-root user (important for security)
+        )
+        print(f"Container started with ID: {container.id}")
+
+        # Wait a moment for the container to fully start and expose its port
+        time.sleep(5) # Increased sleep to give the application within the container more time
+
+        # Retrieve the dynamically assigned host port for the container's 8080 port
+        port_info = docker_client.api.port(container.id, 8080)
+        if not port_info:
+            # If port 8080 is not exposed, the container likely failed to start or is not exposing correctly
+            print(f"Error: Port 8080 not exposed by container {container.id}. Inspecting container logs...")
+            try:
+                container_logs = container.logs().decode('utf-8')
+                print(f"Container logs:\n{container_logs}")
+            except Exception as log_e:
+                print(f"Could not retrieve container logs: {log_e}")
+            container.stop()
+            container.remove(force=True)
+            raise Exception("Port 8080 not exposed by container or container failed to start correctly. Check container logs.")
+
+        host_port = port_info[0]['HostPort']
+        print(f"Container {container.id} is accessible on host port: {host_port}")
+
+        # Step 4: Manage ngrok tunnel
+        # Check if an ngrok tunnel already exists for this project and close it
+        if project_id in deployed_projects and deployed_projects[project_id].get('ngrok_tunnel'):
+            existing_tunnel = deployed_projects[project_id]['ngrok_tunnel']
+            print(f"Closing existing ngrok tunnel: {existing_tunnel.public_url}")
+            try:
+                existing_tunnel.disconnect()
+            except Exception as ngrok_disconnect_e:
+                print(f"Error disconnecting existing ngrok tunnel: {ngrok_disconnect_e}")
+            deployed_projects[project_id]['ngrok_tunnel'] = None # Clear the reference
+
+        # Connect a new ngrok tunnel to the dynamically assigned host port
+        print(f"Connecting new ngrok tunnel to host port {host_port}")
+        tunnel = ngrok.connect(host_port, bind_tls=True) # bind_tls=True for HTTPS
+        public_url = tunnel.public_url
+        print(f"Ngrok public URL for {app_name}: {public_url}")
+
+        # Step 5: Update global state with new deployment details
+        # Ensure the project_id exists in deployed_projects before updating
+        if project_id not in deployed_projects:
+            deployed_projects[project_id] = {} # Initialize if not already present (should be by deploy_from_git)
+
+        deployed_projects[project_id].update({
+            "container_id": container.id,
+            "container_name": container_name,
+            "ngrok_tunnel": tunnel,
+            "public_url": public_url,
+            "status": "deployed" # Set status to deployed on success
+        })
+
+        return public_url, container_name
+
+    except docker.errors.BuildError as e:
+        print(f"Docker build error: {e}")
+        # Capture and return detailed build logs for better debugging
+        build_logs_str = "\n".join([str(log_line.get('stream', '')).strip() for log_line in e.build_log if 'stream' in log_line])
+        if project_id in deployed_projects:
+            deployed_projects[project_id]["status"] = "failed"
+        raise HTTPException(status_code=500, detail=f"Docker build failed: {e.msg}\nLogs:\n{build_logs_str}")
+    except docker.errors.ContainerError as e:
+        print(f"Docker container runtime error: {e}")
+        if project_id in deployed_projects:
+            deployed_projects[project_id]["status"] = "failed"
+        raise HTTPException(status_code=500, detail=f"Container failed during runtime: {e.stderr.decode()}")
+    except docker.errors.APIError as e:
+        print(f"Docker API error: {e}")
+        if project_id in deployed_projects:
+            deployed_projects[project_id]["status"] = "failed"
+        raise HTTPException(status_code=500, detail=f"Docker daemon or API error: {e.explanation}")
+    except Exception as e:
+        print(f"General deployment error: {e}")
+        if project_id in deployed_projects:
+            deployed_projects[project_id]["status"] = "failed"
+        raise HTTPException(status_code=500, detail=f"Deployment process failed unexpectedly: {str(e)}")
+
+# --- API Endpoints ---
+
+@router.post("/project")
+async def deploy_from_git(repo_url: str = Form(...), app_name: str = Form(...)):
+    """
+    Deploys a FastAPI/Flask application from a specified Git repository.
+    The repository must contain a main.py, requirements.txt, and Dockerfile.
+    """
+    # Basic validation for the Git repository URL format
+    if not repo_url.startswith(("http://", "https://", "git@", "ssh://")):
+        raise HTTPException(status_code=400, detail="Invalid Git repository URL format. Must be HTTP(S) or SSH.")
+
+    # Generate a unique ID for this project
+    project_id = str(uuid.uuid4())
+    
+    # Define project directories
+    base_dir = os.path.dirname(os.path.abspath(__file__)) # This is where 'router.py' is
+    projects_dir = os.path.abspath(os.path.join(base_dir, "..", "projects")) # Parent directory's 'projects' folder
+    os.makedirs(projects_dir, exist_ok=True) # Ensure the base projects directory exists
+
+    project_path = os.path.join(projects_dir, project_id)
+    os.makedirs(project_path, exist_ok=True) # Create a unique directory for this project
+
+    try:
+        # Step 1: Clone the Git repository
+        print(f"Cloning repository {repo_url} into {project_path}")
+        git.Repo.clone_from(repo_url, project_path)
+        print("Repository cloned successfully.")
+
+    except git.exc.GitCommandError as e:
+        print(f"Git clone failed: {e.stderr.decode()}")
+        # Clean up the partially created project directory if cloning fails
+        if os.path.exists(project_path):
+            import shutil
+            shutil.rmtree(project_path)
+        raise HTTPException(status_code=400, detail=f"Failed to clone repository: {e.stderr.decode()}")
+    except Exception as e:
+        print(f"Unexpected error during git clone: {e}")
+        if os.path.exists(project_path):
+            import shutil
+            shutil.rmtree(project_path)
+        raise HTTPException(status_code=500, detail=f"An unexpected error occurred during repository cloning: {str(e)}")
+
+    # Step 2: Validate required project files (main.py, requirements.txt, Dockerfile)
+    main_py_path = _find_file_in_project("main.py", project_path)
+    requirements_txt_path = _find_file_in_project("requirements.txt", project_path)
+    dockerfile_path = _find_file_in_project("Dockerfile", project_path)
+
+    missing_files = []
+    if not main_py_path:
+        missing_files.append("main.py")
+    if not requirements_txt_path:
+        missing_files.append("requirements.txt")
+    if not dockerfile_path:
+        missing_files.append("Dockerfile")
+
+    if missing_files:
+        # Clean up the project directory if essential files are missing
+        if os.path.exists(project_path):
+            import shutil
+            shutil.rmtree(project_path)
+        raise HTTPException(
+            status_code=400,
+            detail=f"The cloned repository is missing required file(s): {', '.join(missing_files)} (case-insensitive search)."
+        )
+
+    # Ensure Dockerfile is at the root of the project_path for Docker build context
+    if os.path.dirname(dockerfile_path) != project_path:
+        print(f"[DEBUG] Moving Dockerfile from {dockerfile_path} to project root: {project_path}")
+        target_dockerfile_path = os.path.join(project_path, "Dockerfile")
+        os.replace(dockerfile_path, target_dockerfile_path)
+        dockerfile_path = target_dockerfile_path # Update the path to reference the new location
+
+    # Step 3: Store initial project details in global state (or database)
+    deployed_projects[project_id] = {
+        "app_name": app_name,
+        "repo_url": repo_url,
+        "project_path": project_path,
+        "status": "building", # Set initial status
+        "container_name": None, # Will be set by _build_and_deploy
+        "public_url": None, # Will be set by _build_and_deploy
+        "ngrok_tunnel": None # Will be set by _build_and_deploy
+    }
+    print(f"Project {project_id} initialized for deployment.")
+
+    # Step 4: Trigger the build and deploy process
+    try:
+        public_url, container_name = await _build_and_deploy(project_id, project_path, app_name)
+        return JSONResponse({
+            "project_id": project_id,
+            "container_name": container_name,
+            "preview_url": public_url,
+            "message": "Deployment initiated from Git repository. Check logs for status."
+        }, status_code=202) # Use 202 Accepted, as deployment happens in background
+    except HTTPException as e:
+        # If _build_and_deploy raises a specific HTTPException, re-raise it
+        if project_id in deployed_projects:
+            deployed_projects[project_id]["status"] = "failed"
+        raise e
+    except Exception as e:
+        # Catch any other unexpected errors during the build/deploy phase
+        if project_id in deployed_projects:
+            deployed_projects[project_id]["status"] = "failed"
+        print(f"Error during initial _build_and_deploy for project {project_id}: {e}")
+        raise HTTPException(status_code=500, detail=f"Initial deployment failed unexpectedly: {str(e)}")
+
+@router.post("/webhook/github")
+async def github_webhook(request: Request, background_tasks: BackgroundTasks):
+    """
+    Endpoint to receive GitHub webhook events (e.g., push events) and trigger redeployments.
+    """
+    # --- Security: Verify GitHub Webhook Signature ---
+    # This is CRUCIAL to ensure the webhook is from GitHub and hasn't been tampered with.
+    # For production, DO NOT comment this out.
+    signature_header = request.headers.get("X-Hub-Signature-256")
+    if not signature_header:
+        raise HTTPException(status_code=403, detail="X-Hub-Signature-256 header missing.")
+
+    # Read the raw request body once to use for hashing
+    body = await request.body()
+    
+    try:
+        # Calculate expected signature
+        sha_name, signature = signature_header.split("=", 1)
+        if sha_name != "sha256":
+            raise HTTPException(status_code=400, detail="Invalid X-Hub-Signature-256 algorithm. Only sha256 supported.")
+        
+        # Use HMAC-SHA256 with your secret key to hash the raw request body
+        # Ensure the secret is encoded to bytes
+        mac = hmac.new(GITHUB_WEBHOOK_SECRET.encode("utf-8"), body, hashlib.sha256)
+        
+        # Compare the calculated hash with the signature received from GitHub
+        if not hmac.compare_digest(mac.hexdigest(), signature):
+            raise HTTPException(status_code=403, detail="Invalid GitHub signature.")
+    except Exception as e:
+        print(f"Webhook signature verification failed: {e}")
+        raise HTTPException(status_code=403, detail="Signature verification failed.")
+
+    # Parse the JSON payload from the webhook
+    payload = await request.json()
+    github_event = request.headers.get("X-GitHub-Event")
+
+    print(f"Received GitHub '{github_event}' webhook for repository: {payload.get('repository', {}).get('full_name')}")
+
+    # Process only 'push' events
+    if github_event != "push":
+        return JSONResponse({"message": f"Received '{github_event}' event, but only 'push' events are processed."}, status_code=200)
+
+    # Get the repository URL from the webhook payload
+    repo_url_from_webhook = payload.get("repository", {}).get("html_url") # Prefer html_url or clone_url
+    if not repo_url_from_webhook:
+        raise HTTPException(status_code=400, detail="Repository URL not found in webhook payload.")
+
+    # Find the project linked to this repository in our in-memory storage
+    project_to_redeploy = None
+    project_id_to_redeploy = None
+    for project_id, project_data in deployed_projects.items():
+        # Match based on repo_url. A more robust solution might normalize URLs or use repository IDs.
+        if project_data.get("repo_url") == repo_url_from_webhook:
+            project_to_redeploy = project_data
+            project_id_to_redeploy = project_id
+            break
+
+    if not project_to_redeploy:
+        print(f"No active project found for repository: {repo_url_from_webhook}. Webhook ignored.")
+        return JSONResponse({"message": "No associated project found for this repository, ignoring webhook."}, status_code=200)
+
+    print(f"Received push for {repo_url_from_webhook}. Triggering redeployment for project {project_id_to_redeploy} ({project_to_redeploy['app_name']}).")
+
+    # Step 1: Pull the latest changes from the Git repository
+    project_path = project_to_redeploy["project_path"]
+    try:
+        repo = git.Repo(project_path)
+        origin = repo.remotes.origin
+        print(f"Pulling latest changes for {repo_url_from_webhook} into {project_path}")
+        origin.pull() # Pull the latest changes from the remote
+        print("Latest changes pulled successfully.")
+    except git.exc.GitCommandError as e:
+        print(f"Failed to pull latest changes for {repo_url_from_webhook}: {e.stderr.decode()}")
+        # Update project status to failed if pull fails
+        deployed_projects[project_id_to_redeploy]["status"] = "failed"
+        return JSONResponse({"error": f"Failed to pull latest changes: {e.stderr.decode()}"}, status_code=500)
+    except Exception as e:
+        print(f"Unexpected error during git pull: {e}")
+        deployed_projects[project_id_to_redeploy]["status"] = "failed"
+        return JSONResponse({"error": f"An unexpected error occurred during git pull: {str(e)}"}, status_code=500)
+
+    # Step 2: Trigger redeployment in a background task
+    # Using FastAPI's BackgroundTasks ensures the webhook endpoint returns immediately,
+    # preventing timeouts for GitHub, while the redeployment happens asynchronously.
+    
+    # Get the current container name for proper cleanup in _build_and_deploy
+    current_container_name = project_to_redeploy.get("container_name")
+
+    # Add the build and deploy task to background tasks
+    background_tasks.add_task(
+        _build_and_deploy,
+        project_id_to_redeploy,
+        project_path,
+        project_to_redeploy["app_name"],
+        current_container_name # Pass existing container name for cleanup
+    )
+    
+    # Update project status to indicate redeployment is in progress
+    deployed_projects[project_id_to_redeploy]["status"] = "redeploying"
+
+    return JSONResponse(
+        {"message": f"Redeployment for project {project_id_to_redeploy} initiated from GitHub webhook."},
+        background=background_tasks,
+        status_code=202 # 202 Accepted: request has been accepted for processing
+    )
+
+# --- Cleanup Endpoint (Optional, for manual testing/management) ---
+@router.post("/project/delete/{project_id}")
+async def delete_project(project_id: str):
+    """
+    Deletes a deployed project, its Docker container, ngrok tunnel, and local files.
+    """
+    if project_id not in deployed_projects:
+        raise HTTPException(status_code=404, detail=f"Project with ID {project_id} not found.")
+
+    project_data = deployed_projects[project_id]
+    
+    # Stop and remove Docker container
+    docker_client = docker.from_env()
+    container_name = project_data.get("container_name")
+    if container_name:
+        try:
+            container = docker_client.containers.get(container_name)
+            container.stop(timeout=5)
+            container.remove(force=True)
+            print(f"Container {container_name} for project {project_id} removed.")
+        except docker.errors.NotFound:
+            print(f"Container {container_name} not found, already removed?")
+        except Exception as e:
+            print(f"Error removing container {container_name}: {e}")
+            # Do not raise HTTPException, try to continue cleanup
+
+    # Disconnect ngrok tunnel
+    ngrok_tunnel = project_data.get("ngrok_tunnel")
+    if ngrok_tunnel:
+        try:
+            ngrok_tunnel.disconnect()
+            print(f"Ngrok tunnel for project {project_id} disconnected.")
+        except Exception as e:
+            print(f"Error disconnecting ngrok tunnel for project {project_id}: {e}")
+    
+    # Remove local project directory
+    project_path = project_data.get("project_path")
+    if project_path and os.path.exists(project_path):
+        try:
+            import shutil
+            shutil.rmtree(project_path)
+            print(f"Project directory {project_path} removed.")
+        except Exception as e:
+            print(f"Error removing project directory {project_path}: {e}")
+
+    # Remove from global state
+    del deployed_projects[project_id]
+    print(f"Project {project_id} removed from deployed_projects.")
+
+    return JSONResponse({"message": f"Project {project_id} and associated resources deleted."})
+

routers/logs.py

@@ -0,0 +1,16 @@
+from fastapi import APIRouter
+from fastapi.responses import JSONResponse, HTMLResponse
+import docker
+
+router = APIRouter()
+
+docker_client = docker.from_env()
+
+@router.get("/fetch/{container_name}")
+def stream_logs(container_name: str):
+    try:
+        container = docker_client.containers.get(container_name)
+        logs = container.logs(tail=100).decode()
+        return HTMLResponse(f"<pre>{logs}</pre>")
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)

templates/dashboard.html

@@ -0,0 +1,102 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>FastHost Dashboard</title>
+  <style>
+    body {
+      font-family: Arial, sans-serif;
+      background: #f8f9fa;
+      padding: 20px;
+    }
+    h1 {
+      color: #343a40;
+    }
+    .card {
+      background: white;
+      padding: 15px;
+      margin: 10px 0;
+      border-radius: 8px;
+      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+    .buttons button {
+      margin-right: 5px;
+    }
+    pre {
+      background: #e9ecef;
+      padding: 10px;
+      max-height: 200px;
+      overflow-y: auto;
+    }
+  </style>
+</head>
+<body>
+  <h1>🚀 FastHost Dashboard</h1>
+  <div id="projects"></div>
+
+  <script>
+    async function fetchProjects() {
+      const res = await fetch('/projects');
+      const data = await res.json();
+      const container = document.getElementById('projects');
+      container.innerHTML = '';
+
+      data.forEach(proj => {
+        const card = document.createElement('div');
+        card.className = 'card';
+
+        card.innerHTML = `
+          <h3>${proj.name}</h3>
+          <p>Status: <b>${proj.status}</b></p>
+          <p>Public URL: <a href="${proj.public_url}" target="_blank">${proj.public_url}</a></p>
+          <p>Local URL: <a href="${proj.local_url}" target="_blank">${proj.local_url}</a></p>
+          <div class="buttons">
+            <button onclick="stopProject('${proj.container_name}')">🛑 Stop</button>
+            <button onclick="startProject('${proj.container_name}')">▶️ Start</button>
+            <button onclick="pauseProject('${proj.container_name}')">⏸️ Pause</button>
+            <button onclick="toggleLogs('${proj.container_name}')">📜 View Logs</button>
+          </div>
+          <pre id="log-${proj.container_name}" style="display:none"></pre>
+        `;
+
+        container.appendChild(card);
+      });
+    }
+
+    async function stopProject(containerName) {
+      await fetch(`/controls/stop/${containerName}`);
+      fetchProjects();
+    }
+
+    async function startProject(containerName) {
+        await fetch(`/controls/start/${containerName}`);
+      fetchProjects();
+    }
+
+    async function pauseProject(containerName) {
+        await fetch(`/controls/pause/${containerName}`);
+      fetchProjects();
+    }
+
+    function toggleLogs(containerName) {
+      const pre = document.getElementById(`log-${containerName}`);
+      if (pre.style.display === 'none') {
+        pre.style.display = 'block';
+        fetchLogs(containerName, pre);
+      } else {
+        pre.style.display = 'none';
+      }
+    }
+
+    async function fetchLogs(containerName, target) {
+        const res = await fetch(`/logs/fetch/${containerName}`);
+        const logs = await res.text();
+        target.innerHTML = logs;
+    }
+
+    fetchProjects();
+    setInterval(fetchProjects, 5000); // Refresh every 5 seconds
+  </script>
+</body>
+</html>

upload.py

@@ -0,0 +1,41 @@
+import os
+import zipfile
+import requests
+import dotenv
+
+# Load environment variables
+dotenv.load_dotenv()
+
+def zip_folder(source_dir, zip_path):
+    with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+        for root, _, files in os.walk(source_dir):
+            for file in files:
+                file_path = os.path.join(root, file)
+                arcname = os.path.relpath(file_path, start=source_dir)
+                zipf.write(file_path, arcname)
+
+def upload_zip(zip_path, app_name, server_url):
+    with open(zip_path, 'rb') as f:
+        files = {'file': (os.path.basename(zip_path), f, 'application/zip')}
+        data = {'app_name': app_name}
+        response = requests.post(f'{server_url}/deploy/project', files=files, data=data)
+
+    if response.status_code == 200:
+        print("✅ Deployed Successfully!")
+        print(response.json())
+    else:
+        print("❌ Deployment Failed:")
+        print(response.text)
+
+if __name__ == "__main__":
+    # Configuration
+    folder_to_zip = "examples/test"               # Folder with main.py and requirements.txt
+    zip_output = "project.zip"
+    app_name = "maouapp"
+    server_url = 'http://192.168.29.195:8000'  # Replace with your server URL
+
+    print("📦 Zipping project...")
+    zip_folder(folder_to_zip, zip_output)
+
+    print("📤 Uploading...")
+    upload_zip(zip_output, app_name, server_url)