xenfra 0.2.2__py3-none-any.whl → 0.2.3__py3-none-any.whl

xenfra/engine.py

@@ -1,293 +0,0 @@
-# src/xenfra/engine.py
-
-import os
-import time
-from pathlib import Path
-import digitalocean
-import fabric
-from dotenv import load_dotenv
-from sqlmodel import Session
-
-# Xenfra modules
-from . import dockerizer
-from . import recipes
-from .db.models import Project
-from .db.session import get_session
-
-class DeploymentError(Exception):
-    """Custom exception for deployment failures."""
-    def __init__(self, message, stage="Unknown"):
-        self.message = message
-        self.stage = stage
-        super().__init__(f"Deployment failed at stage '{stage}': {message}")
-
-class InfraEngine:
-    """
-    The InfraEngine is the core of Xenfra. It handles all interactions
-    with the cloud provider and orchestrates the deployment lifecycle.
-    """
-    def __init__(self, token: str = None, db_session: Session = None):
-        """
-        Initializes the engine and validates the API token.
-        """
-        load_dotenv()
-        self.token = token or os.getenv("DIGITAL_OCEAN_TOKEN")
-        self.db_session = db_session or next(get_session())
-
-        if not self.token:
-            raise ValueError("DigitalOcean API token not found. Please set the DIGITAL_OCEAN_TOKEN environment variable.")
-        try:
-            self.manager = digitalocean.Manager(token=self.token)
-            self.get_user_info()
-        except Exception as e:
-            raise ConnectionError(f"Failed to connect to DigitalOcean: {e}")
-
-    def _get_connection(self, ip_address: str):
-        """Establishes a Fabric connection to the server."""
-        private_key_path = str(Path.home() / ".ssh" / "id_rsa")
-        if not Path(private_key_path).exists():
-            raise DeploymentError("No private SSH key found at ~/.ssh/id_rsa.", stage="Setup")
-
-        return fabric.Connection(
-            host=ip_address,
-            user="root",
-            connect_kwargs={"key_filename": [private_key_path]},
-        )
-
-    def get_user_info(self):
-        """Retrieves user account information."""
-        return self.manager.get_account()
-
-    def list_servers(self):
-        """Retrieves a list of all Droplets."""
-        return self.manager.get_all_droplets()
-
-    def destroy_server(self, droplet_id: int, db_session: Session = None):
-        """Destroys a Droplet by its ID and removes it from the local DB."""
-        session = db_session or self.db_session
-        
-        # Find the project in the local DB
-        project_to_delete = session.query(Project).filter(Project.droplet_id == droplet_id).first()
-
-        # Destroy the droplet on DigitalOcean
-        droplet = digitalocean.Droplet(token=self.token, id=droplet_id)
-        droplet.destroy()
-
-        # If it was in our DB, delete it
-        if project_to_delete:
-            session.delete(project_to_delete)
-            session.commit()
-
-    def list_projects_from_db(self, db_session: Session = None):
-        """Lists all projects from the local database."""
-        session = db_session or self.db_session
-        return session.query(Project).all()
-
-    def sync_with_provider(self, db_session: Session = None):
-        """Reconciles the local database with the live state from DigitalOcean."""
-        session = db_session or self.db_session
-        
-        # 1. Get live and local states
-        live_droplets = self.manager.get_all_droplets(tag_name="xenfra")
-        local_projects = self.list_projects_from_db(session)
-
-        live_map = {d.id: d for d in live_droplets}
-        local_map = {p.droplet_id: p for p in local_projects}
-
-        # 2. Reconcile
-        # Add new servers found on DO to our DB
-        for droplet_id, droplet in live_map.items():
-            if droplet_id not in local_map:
-                new_project = Project(
-                    droplet_id=droplet.id, name=droplet.name, ip_address=droplet.ip_address,
-                    status=droplet.status, region=droplet.region['slug'], size=droplet.size_slug
-                )
-                session.add(new_project)
-
-        # Remove servers from our DB that no longer exist on DO
-        for project_id, project in local_map.items():
-            if project_id not in live_map:
-                session.delete(project)
-        
-        session.commit()
-        return self.list_projects_from_db(session)
-
-    def stream_logs(self, droplet_id: int, db_session: Session = None):
-        """
-        Verifies a server exists and streams its logs in real-time.
-        """
-        session = db_session or self.db_session
-        
-        # 1. Find project in local DB
-        project = session.query(Project).filter(Project.droplet_id == droplet_id).first()
-        if not project:
-            raise DeploymentError(f"Project with Droplet ID {droplet_id} not found in local database.", stage="Log Streaming")
-
-        # 2. Just-in-Time Verification
-        try:
-            droplet = self.manager.get_droplet(droplet_id)
-        except digitalocean.baseapi.DataReadError as e:
-            if e.response.status_code == 404:
-                # The droplet doesn't exist, so remove it from our DB
-                session.delete(project)
-                session.commit()
-                raise DeploymentError(f"Server '{project.name}' (ID: {droplet_id}) no longer exists on DigitalOcean. It has been removed from your local list.", stage="Log Streaming")
-            else:
-                raise e
-        
-        # 3. Stream logs
-        ip_address = droplet.ip_address
-        with self._get_connection(ip_address) as conn:
-            conn.run("cd /root/app && docker-compose logs -f app", pty=True)
-
-
-
-    def _ensure_ssh_key(self, logger):
-        """Ensures a local public SSH key is on DigitalOcean."""
-        pub_key_path = Path.home() / ".ssh" / "id_rsa.pub"
-        if not pub_key_path.exists():
-            raise DeploymentError("No SSH key found at ~/.ssh/id_rsa.pub. Please generate one.", stage="Setup")
-        
-        with open(pub_key_path) as f:
-            pub_key_content = f.read()
-
-        existing_keys = self.manager.get_all_sshkeys()
-        for key in existing_keys:
-            if key.public_key.strip() == pub_key_content.strip():
-                logger("   - Found existing SSH key on DigitalOcean.")
-                return key
-
-        logger("   - No matching SSH key found. Creating a new one on DigitalOcean...")
-        key = digitalocean.SSHKey(token=self.token, name="xenfra-cli-key", public_key=pub_key_content)
-        key.create()
-        return key
-
-    def deploy_server(self, name: str, region: str, size: str, image: str, logger: callable, db_session: Session = None, **kwargs):
-        """A stateful, blocking orchestrator for deploying a new server."""
-        droplet = None
-        session = db_session or self.db_session
-        try:
-            # === 1. SETUP STAGE ===
-            logger("\n[bold blue]PHASE 1: SETUP[/bold blue]")
-            ssh_key = self._ensure_ssh_key(logger)
-
-            # === 2. ASSET GENERATION STAGE ===
-            logger("\n[bold blue]PHASE 2: GENERATING DEPLOYMENT ASSETS[/bold blue]")
-            context = {**kwargs} # Pass db config, etc.
-            files = dockerizer.generate_templated_assets(context)
-            for file in files:
-                logger(f"   - Generated {file}")
-
-            # === 3. CLOUD-INIT STAGE ===
-            logger("\n[bold blue]PHASE 3: CREATING SERVER SETUP SCRIPT[/bold blue]")
-            cloud_init_script = recipes.generate_stack(context)
-            logger("   - Generated cloud-init script.")
-            logger(f"--- Cloud-init script content ---\n{cloud_init_script}\n---------------------------------")
-
-            # === 4. DROPLET CREATION STAGE ===
-            logger("\n[bold blue]PHASE 4: PROVISIONING SERVER[/bold blue]")
-            droplet = digitalocean.Droplet(
-                token=self.token, name=name, region=region, image=image, size_slug=size,
-                ssh_keys=[ssh_key], userdata=cloud_init_script, tags=["xenfra"]
-            )
-            droplet.create()
-            logger(f"   - Droplet '{name}' creation initiated (ID: {droplet.id}). Waiting for it to become active...")
-
-            # === 5. POLLING STAGE ===
-            logger("\n[bold blue]PHASE 5: WAITING FOR SERVER SETUP[/bold blue]")
-            while True:
-                droplet.load()
-                if droplet.status == 'active':
-                    logger("   - Droplet is active. Waiting for SSH to be available...")
-                    break
-                time.sleep(10)
-
-            ip_address = droplet.ip_address
-
-            # Retry SSH connection
-            conn = None
-            max_retries = 12 # 2-minute timeout for SSH
-            for i in range(max_retries):
-                try:
-                    logger(f"   - Attempting SSH connection ({i+1}/{max_retries})...")
-                    conn = self._get_connection(ip_address)
-                    conn.open() # Explicitly open the connection
-                    logger("   - SSH connection established.")
-                    break
-                except Exception as e:
-                    if i < max_retries - 1:
-                        logger(f"   - SSH connection failed. Retrying in 10s...")
-                        time.sleep(10)
-                    else:
-                        raise DeploymentError(f"Failed to establish SSH connection: {e}", stage="Polling")
-
-            if not conn or not conn.is_connected:
-                raise DeploymentError("Could not establish SSH connection.", stage="Polling")
-
-            with conn:
-                for i in range(30): # 5-minute timeout for cloud-init
-                    if conn.run("test -f /root/setup_complete", warn=True).ok:
-                        logger("   - Cloud-init setup complete.")
-                        break
-                    time.sleep(10)
-                else:
-                    raise DeploymentError("Server setup script failed to complete in time.", stage="Polling")
-
-            # === 6. CODE UPLOAD STAGE ===
-            logger("\n[bold blue]PHASE 6: UPLOADING APPLICATION CODE[/bold blue]")
-            with self._get_connection(ip_address) as conn:
-                fabric.transfer.Transfer(conn).upload(".", "/root/app", exclude=[".git", ".venv", "__pycache__"])
-            logger("   - Code upload complete.")
-
-            # === 7. FINAL DEPLOY STAGE ===
-            logger("\n[bold blue]PHASE 7: BUILDING AND DEPLOYING CONTAINERS[/bold blue]")
-            with self._get_connection(ip_address) as conn:
-                result = conn.run("cd /root/app && docker-compose up -d --build", hide=True)
-                if result.failed:
-                    raise DeploymentError(f"docker-compose failed: {result.stderr}", stage="Deploy")
-            logger("   - Docker containers are building in the background...")
-
-            # === 8. VERIFICATION STAGE ===
-            logger("\n[bold blue]PHASE 8: VERIFYING DEPLOYMENT[/bold blue]")
-            app_port = context.get('port', 8000)
-            for i in range(24): # 2-minute timeout for health checks
-                logger(f"   - Health check attempt {i+1}/24...")
-                with self._get_connection(ip_address) as conn:
-                    # Check if container is running
-                    ps_result = conn.run("cd /root/app && docker-compose ps", hide=True)
-                    if "running" not in ps_result.stdout:
-                        time.sleep(5)
-                        continue
-                    
-                    # Check if application is responsive
-                    curl_result = conn.run(f"curl -s --fail http://localhost:{app_port}/", warn=True)
-                    if curl_result.ok:
-                        logger("[bold green]   - Health check passed! Application is live.[/bold green]")
-                        
-                        # === 9. PERSISTENCE STAGE ===
-                        logger("\n[bold blue]PHASE 9: SAVING DEPLOYMENT TO DATABASE[/bold blue]")
-                        project = Project(
-                            droplet_id=droplet.id,
-                            name=droplet.name,
-                            ip_address=ip_address,
-                            status=droplet.status,
-                            region=droplet.region['slug'],
-                            size=droplet.size_slug,
-                        )
-                        session.add(project)
-                        session.commit()
-                        logger("   - Deployment saved.")
-
-                        return droplet # Return the full droplet object
-                time.sleep(5)
-            else:
-                # On failure, get logs and destroy droplet
-                with self._get_connection(ip_address) as conn:
-                    logs = conn.run("cd /root/app && docker-compose logs", hide=True).stdout
-                raise DeploymentError(f"Application failed to become healthy in time. Logs:\n{logs}", stage="Verification")
-
-        except Exception as e:
-            if droplet:
-                logger(f"[bold red]Deployment failed. The server '{droplet.name}' will NOT be cleaned up for debugging purposes.[/bold red]")
-                # droplet.destroy() # Commented out for debugging
-            raise e

xenfra/mcp_client.py

@@ -1,149 +0,0 @@
-# src/xenfra/mcp_client.py
-
-import json
-import subprocess
-import os
-import tempfile
-import base64
-from pathlib import Path
-
-class MCPClient:
-    """
-    A client for communicating with a local github-mcp-server process.
-
-    This client starts the MCP server as a subprocess and interacts with it
-    over stdin and stdout to download a full repository to a temporary directory.
-    """
-
-    def __init__(self, mcp_server_path="github-mcp-server"):
-        """
-        Initializes the MCPClient.
-
-        Args:
-            mcp_server_path (str): The path to the github-mcp-server executable.
-                                   Assumes it's in the system's PATH by default.
-        """
-        self.mcp_server_path = mcp_server_path
-        self.process = None
-
-    def _start_server(self):
-        """Starts the github-mcp-server subprocess."""
-        if self.process and self.process.poll() is None:
-            return
-        try:
-            self.process = subprocess.Popen(
-                [self.mcp_server_path],
-                stdin=subprocess.PIPE,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True,
-                env=os.environ
-            )
-        except FileNotFoundError:
-            raise RuntimeError(f"'{self.mcp_server_path}' not found. Ensure github-mcp-server is installed and in your PATH.")
-        except Exception as e:
-            raise RuntimeError(f"Failed to start MCP server: {e}")
-
-    def _stop_server(self):
-        """Stops the MCP server process."""
-        if self.process:
-            self.process.terminate()
-            self.process.wait()
-            self.process = None
-
-    def _send_request(self, method: str, params: dict) -> dict:
-        """Sends a JSON-RPC request and returns the response."""
-        if not self.process or self.process.poll() is not None:
-            self._start_server()
-
-        request = {"jsonrpc": "2.0", "id": os.urandom(4).hex(), "method": method, "params": params}
-        
-        try:
-            self.process.stdin.write(json.dumps(request) + '\n')
-            self.process.stdin.flush()
-            response_line = self.process.stdout.readline()
-            if not response_line:
-                error_output = self.process.stderr.read()
-                raise RuntimeError(f"MCP server closed stream unexpectedly. Error: {error_output}")
-            
-            response = json.loads(response_line)
-            if "error" in response:
-                raise RuntimeError(f"MCP server returned an error: {response['error']}")
-            return response.get("result", {})
-        except (BrokenPipeError, json.JSONDecodeError) as e:
-            raise RuntimeError(f"Failed to communicate with MCP server: {e}")
-
-    def download_repo_to_tempdir(self, repo_url: str, commit_sha: str = "HEAD") -> str:
-        """
-        Downloads an entire repository at a specific commit to a local temporary directory.
-
-        Args:
-            repo_url (str): The full URL of the GitHub repository.
-            commit_sha (str): The commit SHA to download. Defaults to "HEAD".
-
-        Returns:
-            The path to the temporary directory containing the downloaded code.
-        """
-        try:
-            parts = repo_url.strip('/').split('/')
-            owner = parts[-2]
-            repo_name = parts[-1].replace('.git', '')
-        except IndexError:
-            raise ValueError("Invalid repository URL format. Expected format: https://github.com/owner/repo")
-
-        print(f"   [MCP] Fetching file tree for {owner}/{repo_name} at {commit_sha}...")
-        tree_result = self._send_request(
-            method="git.get_repository_tree",
-            params={"owner": owner, "repo": repo_name, "tree_sha": commit_sha, "recursive": True}
-        )
-
-        tree = tree_result.get("tree", [])
-        if not tree:
-            raise RuntimeError("Could not retrieve repository file tree.")
-
-        temp_dir = tempfile.mkdtemp(prefix=f"xenfra_{repo_name}_")
-        print(f"   [MCP] Downloading to temporary directory: {temp_dir}")
-
-        for item in tree:
-            item_path = item.get("path")
-            item_type = item.get("type")
-
-            if not item_path or item_type != "blob":  # Only handle files
-                continue
-            
-            # For downloading content, we can use the commit_sha in the 'ref' parameter
-            # to ensure we get the content from the correct version.
-            content_result = self._send_request(
-                method="repos.get_file_contents",
-                params={"owner": owner, "repo": repo_name, "path": item_path, "ref": commit_sha}
-            )
-
-            content_b64 = content_result.get("content")
-            if content_b64 is None:
-                print(f"   [MCP] [Warning] Could not get content for {item_path}")
-                continue
-
-            try:
-                # Content is base64 encoded, with newlines.
-                decoded_content = base64.b64decode(content_b64.replace('\n', ''))
-            except (base64.binascii.Error, TypeError):
-                print(f"   [MCP] [Warning] Could not decode content for {item_path}")
-                continue
-
-            # Create file and parent directories in the temp location
-            local_file_path = Path(temp_dir) / item_path
-            local_file_path.parent.mkdir(parents=True, exist_ok=True)
-            
-            # Write the file content
-            with open(local_file_path, "wb") as f:
-                f.write(decoded_content)
-
-        print("   [MCP] ✅ Repository download complete.")
-        return temp_dir
-
-    def __enter__(self):
-        self._start_server()
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self._stop_server()

xenfra/models.py

@@ -1,54 +0,0 @@
-from enum import Enum
-from datetime import datetime
-from pydantic import BaseModel, Field
-
-class DeploymentStatus(str, Enum):
-    PENDING = "pending"
-    IN_PROGRESS = "in_progress"
-    SUCCESS = "success"
-    FAILED = "failed"
-
-class SourceType(str, Enum):
-    LOCAL = "local"
-    GIT = "git"
-
-class Deployment(BaseModel):
-    id: str = Field(..., description="Unique identifier for the deployment")
-    projectId: str = Field(..., description="Identifier of the project being deployed")
-    status: DeploymentStatus = Field(..., description="Current status of the deployment")
-    source: str = Field(..., description="Source of the deployment (e.g., 'cli', 'api')")
-    created_at: datetime = Field(..., description="Timestamp when the deployment was created")
-    finished_at: datetime | None = Field(None, description="Timestamp when the deployment finished")
-
-class DeploymentRecord(BaseModel):
-    deployment_id: str = Field(..., description="Unique identifier for this deployment instance.")
-    timestamp: datetime = Field(..., description="Timestamp of when the deployment succeeded.")
-    source_type: SourceType = Field(..., description="The type of the source code (local or git).")
-    source_identifier: str = Field(..., description="The identifier for the source (commit SHA for git, archive path for local).")
-
-class BalanceRead(BaseModel):
-    month_to_date_balance: str
-    account_balance: str
-    month_to_date_usage: str
-    generated_at: str
-    error: str | None = None
-
-class DropletCostRead(BaseModel):
-    id: int
-    name: str
-    ip_address: str
-    status: str
-    size_slug: str
-    monthly_price: float
-
-class ProjectRead(BaseModel):
-    id: int
-    name: str
-    ip_address: str | None = None
-    status: str
-    region: str
-    size_slug: str
-    estimated_monthly_cost: float | None = None
-    created_at: datetime
-
-

xenfra/recipes.py

@@ -1,23 +0,0 @@
-from jinja2 import Environment, FileSystemLoader
-from pathlib import Path
-
-def generate_stack(context: dict):
-    """
-    Generates a cloud-init startup script from a Jinja2 template.
-    
-    Args:
-        context: A dictionary containing information for rendering the template,
-                 e.g., {'domain': 'example.com', 'email': 'user@example.com'}
-    """
-    # Path to the templates directory
-    template_dir = Path(__file__).parent / "templates"
-    env = Environment(loader=FileSystemLoader(template_dir))
-
-    template = env.get_template("cloud-init.sh.j2")
-    
-    # The non-dockerized logic has been removed as we are focusing on
-    # a purely Docker-based deployment strategy for simplicity and scalability.
-    # The context will contain all necessary variables for the template.
-    script = template.render(context)
-    
-    return script

xenfra/security.py

@@ -1,58 +0,0 @@
-# src/xenfra/security.py
-
-from datetime import datetime, timedelta, timezone
-from typing import Optional
-from passlib.context import CryptContext
-from jose import JWTError, jwt
-from cryptography.fernet import Fernet
-
-from xenfra.config import settings
-
-# --- Configuration ---
-SECRET_KEY = settings.SECRET_KEY
-ALGORITHM = "HS256"
-ACCESS_TOKEN_EXPIRE_MINUTES = 30
-
-# This key MUST be 32 url-safe base64-encoded bytes.
-fernet = Fernet(settings.ENCRYPTION_KEY.encode())
-
-# --- Password Hashing ---
-# Explicitly use passlib.backends.bcrypt
-pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
-
-def verify_password(plain_password: str, hashed_password: str) -> bool:
-    return pwd_context.verify(plain_password, hashed_password)
-
-def get_password_hash(password: str) -> str:
-    # bcrypt passwords cannot be longer than 72 bytes. Truncate if necessary.
-    # Note: Frontend should also enforce password length limits.
-    if len(password.encode('utf-8')) > 72:
-        password = password[:72]
-    return pwd_context.hash(password)
-
-# --- JWT Handling ---
-def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
-    to_encode = data.copy()
-    if expires_delta:
-        expire = datetime.now(timezone.utc) + expires_delta
-    else:
-        expire = datetime.now(timezone.utc) + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
-    to_encode.update({"exp": expire})
-    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
-    return encoded_jwt
-
-def decode_token(token: str) -> Optional[dict]:
-    try:
-        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
-        return payload
-    except JWTError:
-        return None
-
-# --- Token Encryption ---
-def encrypt_token(token: str) -> str:
-    """Encrypts a token using Fernet symmetric encryption."""
-    return fernet.encrypt(token.encode()).decode()
-
-def decrypt_token(encrypted_token: str) -> str:
-    """Decrypts a token."""
-    return fernet.decrypt(encrypted_token.encode()).decode()

xenfra/templates/Dockerfile.j2

@@ -1,25 +0,0 @@
-# Dockerfile template for Python web applications
-FROM {{ python_version | default('python:3.11-slim') }}
-
-WORKDIR /app
-
-# Install uv, our preferred package manager
-RUN apt-get update && apt-get install -y curl && \
-    curl -LsSf https://astral.sh/uv/install.sh | sh && \
-    apt-get remove -y curl && \
-    apt-get clean && \
-    rm -rf /var/lib/apt/lists/*
-
-COPY requirements.txt .
-
-# Install dependencies
-RUN /root/.cargo/bin/uv pip install --system --no-cache -r requirements.txt
-
-COPY . .
-
-# Expose the application port
-EXPOSE {{ port | default(8000) }}
-
-# The command to run the application will be in docker-compose.yml
-# This allows for more flexibility
-

xenfra/templates/cloud-init.sh.j2

@@ -1,68 +0,0 @@
-#!/bin/bash
-export DEBIAN_FRONTEND=noninteractive
-LOG="/root/setup.log"
-touch $LOG
-
-echo "--------------------------------" >> $LOG
-echo "🧘 XENFRA: Context-Aware Boot" >> $LOG
-echo "--------------------------------" >> $LOG
-
-# Create App Directory
-mkdir -p /root/app
-cd /root/app
-
-# --- AGGRESSIVE FIX: KILL BACKGROUND UPDATES ---
-echo "⚔️  [0/6] Stopping Background Updates..." >> $LOG
-systemctl stop unattended-upgrades.service || true
-systemctl stop apt-daily.service || true
-systemctl stop apt-daily-upgrade.service || true
-systemctl kill --kill-who=all apt-daily.service || true
-systemctl kill --kill-who=all apt-daily-upgrade.service || true
-
-# Force remove locks if they exist
-rm -f /var/lib/dpkg/lock*
-rm -f /var/lib/apt/lists/lock
-rm -f /var/cache/apt/archives/lock
-dpkg --configure -a || true
-# -----------------------------------------------
-
-# 1. System Updates
-echo "🔄 [1/5] Refreshing Package Lists..." >> $LOG
-apt-get update
-apt-get install -y python3-pip git curl
-
-# 2. Install Docker & Compose
-echo "🐳 [2/5] Installing Docker..." >> $LOG
-apt-get install -y docker.io || (curl -fsSL https://get.docker.com | sh)
-echo "🎶 [3/5] Installing Docker Compose..." >> $LOG
-apt-get install -y docker-compose-v2
-
-# --- DOCKERIZED DEPLOYMENT ---
-echo "📦 [4/5] Installing Caddy..." >> $LOG
-apt-get install -y debian-keyring debian-archive-keyring apt-transport-https
-curl -LsSf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
-curl -LsSf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | tee /etc/apt/sources.list.d/caddy-stable.list
-apt-get update
-apt-get install -y caddy
-
-{% if domain %}
-# Dynamically generate Caddyfile content
-echo "🔒 Writing Caddyfile for {{ domain }}..." >> $LOG
-cat << EOF > /etc/caddy/Caddyfile
-{{ domain }}:80, {{ domain }}:443 {
-    reverse_proxy localhost:{{ port | default(8000) }}
-    tls {{ email }}
-}
-EOF
-{% endif %}
-
-{% if domain %}
-echo "🚀 [5/5] Starting Caddy..." >> $LOG
-systemctl restart caddy
-{% else %}
-echo "✅ [5/5] Skipping Caddy start (no domain specified)." >> $LOG
-{% endif %}
-
-# Finish
-echo "✅ SETUP SCRIPT COMPLETE" >> $LOG
-touch /root/setup_complete