ndev-stack 0.1.0__py3-none-any.whl

ndev/linux/commands/vhost.py

@@ -0,0 +1,350 @@
+import os
+import sys
+import re
+import subprocess
+import shutil
+import typer
+from pathlib import Path
+from rich.console import Console
+from ndev.common.logger import logger
+from typing import Optional
+
+console = Console()
+
+def chown_to_sudo_user(path: Path):
+    sudo_user = os.environ.get("SUDO_USER")
+    if sudo_user:
+        try:
+            import pwd
+            pw = pwd.getpwnam(sudo_user)
+            os.chown(str(path), pw.pw_uid, pw.pw_gid)
+        except Exception:
+            pass
+
+def generate_local_cert(domain: str, certs_dir: Path) -> tuple[Path, Path]:
+    cert_path = certs_dir / f"{domain}.crt"
+    key_path = certs_dir / f"{domain}.key"
+    
+    if cert_path.exists() and key_path.exists():
+        return cert_path, key_path
+        
+    certs_dir.mkdir(parents=True, exist_ok=True)
+    chown_to_sudo_user(certs_dir)
+    
+    sudo_user = os.environ.get("SUDO_USER")
+    if sudo_user:
+        cmd = [
+            "sudo", "-u", sudo_user,
+            "mkcert",
+            "-cert-file", str(cert_path),
+            "-key-file", str(key_path),
+            domain, f"*.{domain}"
+        ]
+    else:
+        cmd = [
+            "mkcert",
+            "-cert-file", str(cert_path),
+            "-key-file", str(key_path),
+            domain, f"*.{domain}"
+        ]
+        
+    subprocess.run(cmd, capture_output=True, text=True, check=True)
+    chown_to_sudo_user(key_path)
+    chown_to_sudo_user(cert_path)
+            
+    return cert_path, key_path
+
+def get_user_ndev_dir() -> Path:
+    sudo_user = os.environ.get("SUDO_USER")
+    if sudo_user:
+        try:
+            import pwd
+            return Path(pwd.getpwnam(sudo_user).pw_dir) / ".ndev"
+        except Exception:
+            pass
+    return Path(os.path.expanduser("~/.ndev"))
+
+def get_installed_php_versions() -> list[dict]:
+    installed = []
+    ndev_dir = get_user_ndev_dir()
+    php_dir = ndev_dir / "php"
+    if php_dir.exists():
+        for path in php_dir.iterdir():
+            if path.is_dir():
+                ver = path.name
+                # get major/minor for socket
+                parts = ver.split(".")
+                if len(parts) >= 2:
+                    mm = f"{parts[0]}{parts[1]}"
+                    label = f"{parts[0]}.{parts[1]}"
+                else:
+                    mm = ver
+                    label = ver
+                sock = ndev_dir / "run" / f"php{mm}.sock"
+                
+                # Check if it is running
+                pid_file = ndev_dir / "run" / f"php-fpm-{mm}.pid"
+                from ndev.linux.runtime.process import is_pid_running, read_pid_file
+                pid = read_pid_file(pid_file)
+                is_running = is_pid_running(pid) if pid else False
+                
+                installed.append({
+                    "version": ver,
+                    "label": label,
+                    "socket": sock,
+                    "running": is_running
+                })
+    # Sort by version
+    from packaging.version import parse as parse_version
+    try:
+        installed.sort(key=lambda x: parse_version(x["version"]))
+    except Exception:
+        installed.sort(key=lambda x: x["version"])
+    return installed
+
+def vhost_cmd(
+    domain: str = typer.Option(None, "--domain", "-d", help="Domain (e.g. project.local)"),
+    root: str = typer.Option(None, "--root", "-r", help="Project Root Directory"),
+    php: str = typer.Option(None, "--php", "-p", help="PHP socket alias, version, or index"),
+    ssl: Optional[bool] = typer.Option(None, "--ssl/--no-ssl", help="Enable SSL/HTTPS with local certificate generation")
+):
+    """Create Nginx Virtual Host config, map to hosts file, and reload Nginx."""
+    if not domain:
+        domain = typer.prompt("Domain (e.g. project.local)").strip()
+    if not domain:
+        logger.error("Domain is required.")
+        raise typer.Exit(code=1)
+        
+    if not root:
+        root = typer.prompt("Project Root").strip()
+    if not root:
+        logger.error("Project Root is required.")
+        raise typer.Exit(code=1)
+        
+    root_path = Path(root)
+    if not root_path.exists() or not root_path.is_dir():
+        logger.error(f"Project root directory does not exist: {root}")
+        raise typer.Exit(code=1)
+        
+    installed_phps = get_installed_php_versions()
+    if not installed_phps:
+        logger.error("No installed PHP versions found. Please install PHP using 'ndev install <version>' first.")
+        raise typer.Exit(code=1)
+        
+    selected_sock = None
+    selected_ver = None
+    if php:
+        # Check if it is a socket path
+        php_path = Path(php)
+        if php_path.exists() and php_path.suffix == ".sock":
+            selected_sock = php_path
+        else:
+            clean_php = php.lower()
+            if clean_php.startswith("ndev "):
+                clean_php = clean_php[len("ndev "):]
+                
+            for item in installed_phps:
+                if clean_php == item["label"].lower() or clean_php == item["version"].lower():
+                    selected_sock = item["socket"]
+                    selected_ver = item["version"]
+                    break
+                    
+            if not selected_sock:
+                try:
+                    idx = int(php)
+                    if 1 <= idx <= len(installed_phps):
+                        selected_sock = installed_phps[idx - 1]["socket"]
+                        selected_ver = installed_phps[idx - 1]["version"]
+                except ValueError:
+                    pass
+                    
+            if not selected_sock:
+                logger.error(f"Invalid PHP selection: {php}")
+                raise typer.Exit(code=1)
+    else:
+        console.print("\n[bold]Available PHP Versions[/bold]")
+        console.print("----------------------")
+        for i, item in enumerate(installed_phps):
+            status = "[green]Running[/green]" if item["running"] else "[yellow]Stopped[/yellow]"
+            console.print(f" {i + 1}) PHP {item['version']} ({item['label']}) - {status}")
+        console.print("")
+        choice = typer.prompt("Select PHP version index", type=int)
+        if choice < 1 or choice > len(installed_phps):
+            logger.error("Invalid selection.")
+            raise typer.Exit(code=1)
+        selected_sock = installed_phps[choice - 1]["socket"]
+        selected_ver = installed_phps[choice - 1]["version"]
+        
+    if ssl is None:
+        ssl = typer.confirm("Enable SSL/HTTPS?", default=False)
+        
+    # If selected PHP version is stopped, start it
+    if selected_ver:
+        selected_item = next((item for item in installed_phps if item["version"] == selected_ver), None)
+        if selected_item and not selected_item["running"]:
+            console.print(f"[yellow]PHP-FPM {selected_ver} is stopped. Starting it...[/yellow]")
+            try:
+                from ndev.linux.runtime.fpm import start_fpm
+                start_fpm(selected_ver)
+            except Exception as e:
+                logger.warning(f"Could not automatically start PHP-FPM: {e}")
+                
+    cert_path, key_path = None, None
+    if ssl:
+        if not shutil.which("mkcert"):
+            logger.error("mkcert binary not found. Please install mkcert to generate local certificates.")
+            raise typer.Exit(code=1)
+        certs_dir = get_user_ndev_dir() / "certs"
+        try:
+            cert_path, key_path = generate_local_cert(domain, certs_dir)
+            console.print(f"Generated SSL Certificates:")
+            console.print(f"  Cert: {cert_path}")
+            console.print(f"  Key : {key_path}")
+        except Exception as e:
+            logger.error(f"Failed to generate SSL certificate: {e}")
+            raise typer.Exit(code=1)
+            
+    if os.geteuid() != 0:
+        console.print("\n[bold yellow]Privileged operations required. Elevating via sudo...[/bold yellow]")
+        cmd = [
+            "sudo",
+            sys.executable,
+            "-m",
+            "ndev",
+            "vhost",
+            "--domain",
+            domain,
+            "--root",
+            root,
+            "--php",
+            str(selected_sock)
+        ]
+        if ssl:
+            cmd.append("--ssl")
+        else:
+            cmd.append("--no-ssl")
+            
+        try:
+            res = subprocess.run(cmd)
+            raise typer.Exit(code=res.returncode)
+        except KeyboardInterrupt:
+            raise typer.Exit(code=1)
+            
+    nginx_available = Path("/etc/nginx/sites-available")
+    nginx_enabled = Path("/etc/nginx/sites-enabled")
+    hosts_file = Path("/etc/hosts")
+    
+    if not nginx_available.exists() or not nginx_enabled.exists():
+        logger.error("Nginx configuration directories not found.")
+        raise typer.Exit(code=1)
+        
+    conf_file = nginx_available / f"{domain}.conf"
+    
+    if ssl:
+        config_template = f"""server {{
+    listen 80;
+    listen [::]:80;
+    server_name {domain};
+    return 301 https://$host$request_uri;
+}}
+
+server {{
+    listen 443 ssl;
+    listen [::]:443 ssl;
+
+    server_name {domain};
+
+    ssl_certificate {cert_path};
+    ssl_certificate_key {key_path};
+
+    root {root};
+    index index.php index.html index.htm;
+
+    access_log /var/log/nginx/{domain}.access.log;
+    error_log  /var/log/nginx/{domain}.error.log;
+
+    location / {{
+        try_files $uri $uri/ /index.php?$query_string;
+    }}
+
+    location ~ \\.php$ {{
+        include snippets/fastcgi-php.conf;
+        fastcgi_pass unix:{selected_sock};
+    }}
+
+    location ~ /\\.ht {{
+        deny all;
+    }}
+}}
+"""
+    else:
+        config_template = f"""server {{
+    listen 80;
+    listen [::]:80;
+
+    server_name {domain};
+
+    root {root};
+    index index.php index.html index.htm;
+
+    access_log /var/log/nginx/{domain}.access.log;
+    error_log  /var/log/nginx/{domain}.error.log;
+
+    location / {{
+        try_files $uri $uri/ /index.php?$query_string;
+    }}
+
+    location ~ \\.php$ {{
+        include snippets/fastcgi-php.conf;
+        fastcgi_pass unix:{selected_sock};
+    }}
+
+    location ~ /\\.ht {{
+        deny all;
+    }}
+}}
+"""
+
+    try:
+        conf_file.write_text(config_template)
+        enabled_link = nginx_enabled / f"{domain}.conf"
+        if enabled_link.exists() or enabled_link.is_symlink():
+            enabled_link.unlink()
+        enabled_link.symlink_to(conf_file)
+        
+        hosts_content = hosts_file.read_text()
+        pattern = rf"^\s*127\.0\.0\.1\s+.*\b{re.escape(domain)}\b"
+        found = False
+        for line in hosts_content.splitlines():
+            if re.match(pattern, line):
+                found = True
+                break
+        if not found:
+            with hosts_file.open("a") as f:
+                f.write(f"\n127.0.0.1 {domain}\n")
+                
+        res = subprocess.run(["nginx", "-t"], capture_output=True, text=True)
+        if res.returncode != 0:
+            logger.error(f"Nginx config test failed:\n{res.stderr}")
+            enabled_link.unlink(missing_ok=True)
+            conf_file.unlink(missing_ok=True)
+            raise typer.Exit(code=1)
+            
+        subprocess.run(["systemctl", "reload", "nginx"], check=True)
+        
+        console.print(f"\n[bold green]VHost Created Successfully[/bold green]")
+        console.print("--------------------------")
+        console.print(f"Domain      : {domain}")
+        console.print(f"Root        : {root}")
+        console.print(f"PHP Socket  : {selected_sock}")
+        console.print(f"Config      : {conf_file}")
+        if ssl:
+            console.print(f"SSL Cert    : {cert_path}")
+            console.print(f"SSL Key     : {key_path}")
+            console.print(f"\nOpen: https://{domain}")
+        else:
+            console.print(f"\nOpen: http://{domain}")
+    except Exception as e:
+        logger.error(f"Failed to create virtual host: {e}")
+        raise typer.Exit(code=1)
+

ndev/linux/php/builder.py

@@ -0,0 +1,183 @@
+import os
+import tarfile
+import shutil
+from pathlib import Path
+from ndev.common.constants import BUILDS_DIR, PHP_DIR
+from ndev.common.logger import logger
+from ndev.linux.chroot.manager import SandboxManager
+from ndev.common.config import load_config
+from ndev.common.manifest import add_installed_version
+
+def extract_archive(archive_path: Path, extract_dir: Path) -> Path:
+    """Extract a tarball to a given directory and return the extracted folder path."""
+    logger.info(f"Extracting {archive_path.name} to {extract_dir}...")
+    extract_dir.mkdir(parents=True, exist_ok=True)
+    
+    with tarfile.open(archive_path) as tar:
+        root_dir_name = None
+        for member in tar.getmembers():
+            parts = Path(member.name).parts
+            if parts and parts[0] != ".":
+                root_dir_name = parts[0]
+                break
+                
+        if not root_dir_name:
+            raise ValueError("Could not find a valid root directory in the tarball.")
+            
+        tar.extractall(path=extract_dir)
+        
+    return extract_dir / root_dir_name
+
+def apply_patches(version: str, build_dir: Path):
+    """Apply patches for a specific PHP version from the patches directory."""
+    major_minor = ".".join(version.split(".")[:2])
+    
+    project_root = Path(__file__).resolve().parents[2]
+    patches_dirs = [
+        project_root / "patches" / version,
+        project_root / "patches" / major_minor,
+    ]
+    
+    import subprocess
+    
+    applied_any = False
+    for patch_dir in patches_dirs:
+        if patch_dir.exists() and patch_dir.is_dir():
+            patch_files = sorted(patch_dir.glob("*.patch")) + sorted(patch_dir.glob("*.diff"))
+            seen = set()
+            for patch_file in patch_files:
+                if patch_file.name in seen:
+                    continue
+                seen.add(patch_file.name)
+                
+                logger.info(f"Applying patch {patch_file.name} for PHP {version}...")
+                try:
+                    subprocess.run(
+                        ["patch", "-p1", "-N", "-t", "-i", str(patch_file)],
+                        cwd=build_dir,
+                        capture_output=True,
+                        text=True,
+                        check=True
+                    )
+                    applied_any = True
+                except subprocess.CalledProcessError as e:
+                    logger.error(f"Failed to apply patch {patch_file.name}: {e.stderr}")
+                    raise e
+                    
+    if not applied_any:
+        logger.debug(f"No patches found for PHP {version}.")
+
+def load_compat_args(version: str) -> str:
+    """Load compatibility compiler flags from the args directory for the given version."""
+    major_minor = ".".join(version.split(".")[:2])
+    
+    project_root = Path(__file__).resolve().parents[2]
+    args_files = [
+        project_root / "args" / f"{version}.txt",
+        project_root / "args" / f"{major_minor}.txt",
+    ]
+    
+    for args_file in args_files:
+        if args_file.exists() and args_file.is_file():
+            try:
+                content = args_file.read_text().strip()
+                return " " + " ".join(content.split())
+            except Exception as e:
+                logger.warning(f"Failed to read args file {args_file}: {e}")
+                
+    return ""
+
+def build_php(version: str, archive_path: Path, show_logs: bool = False) -> Path:
+    """Extract, configure, compile and install PHP inside bubblewrap."""
+    build_dir = BUILDS_DIR / f"php-{version}"
+    if build_dir.exists():
+        shutil.rmtree(build_dir)
+        
+    extracted_path = extract_archive(archive_path, BUILDS_DIR)
+    if extracted_path.resolve() != build_dir.resolve():
+        logger.info(f"Renaming build directory from {extracted_path.name} to {build_dir.name}")
+        shutil.move(str(extracted_path), str(build_dir))
+        
+    # Apply version-specific patches
+    apply_patches(version, build_dir)
+        
+    config = load_config()
+    flags = config.get("build", {}).get("configure_flags", [])
+    
+    install_prefix = PHP_DIR / version
+    if install_prefix.exists():
+        logger.info(f"Removing existing installation at {install_prefix}")
+        shutil.rmtree(install_prefix)
+        
+    configure_args = [
+        "./configure",
+        f"--prefix={install_prefix}",
+        f"--with-config-file-path={install_prefix}/etc",
+        f"--with-config-file-scan-dir={install_prefix}/etc/conf.d",
+    ] + flags
+    
+    env = os.environ.copy()
+    # Avoid pkg-config dependency checks for libraries inside the sandbox
+    env["CURL_CFLAGS"] = "-I/usr/local/include"
+    env["CURL_LIBS"] = "-L/usr/local/lib -L/usr/local/lib/x86_64-linux-gnu -lcurl"
+    
+    env["WEBP_CFLAGS"] = "-I/usr/local/include"
+    env["WEBP_LIBS"] = "-L/usr/local/lib -L/usr/local/lib/x86_64-linux-gnu -lwebp"
+    
+    env["JPEG_CFLAGS"] = "-I/usr/local/include"
+    env["JPEG_LIBS"] = "-L/usr/local/lib -L/usr/local/lib/x86_64-linux-gnu -ljpeg"
+    
+    env["PNG_CFLAGS"] = "-I/usr/local/include"
+    env["PNG_LIBS"] = "-L/usr/local/lib -L/usr/local/lib/x86_64-linux-gnu -lpng"
+    
+    env["FREETYPE2_CFLAGS"] = "-I/usr/local/include/freetype2 -I/usr/local/include"
+    env["FREETYPE2_LIBS"] = "-L/usr/local/lib -L/usr/local/lib/x86_64-linux-gnu -lfreetype"
+    
+    env["LIBSODIUM_CFLAGS"] = "-I/usr/local/include"
+    env["LIBSODIUM_LIBS"] = "-L/usr/local/lib -L/usr/local/lib/x86_64-linux-gnu -lsodium"
+    
+    env["LIBZIP_CFLAGS"] = "-I/usr/local/include"
+    env["LIBZIP_LIBS"] = "-L/usr/local/lib -L/usr/local/lib/x86_64-linux-gnu -lzip"
+    
+    env["ONIG_CFLAGS"] = "-I/usr/local/include"
+    env["ONIG_LIBS"] = "-L/usr/local/lib -L/usr/local/lib/x86_64-linux-gnu -lonig"
+
+    env["ICU_CFLAGS"] = "-I/usr/local/include"
+    env["ICU_LIBS"] = "-L/usr/local/lib -L/usr/local/lib/x86_64-linux-gnu -licui18n -licuuc -licudata -licuio"
+
+    compat_flags = load_compat_args(version)
+    if compat_flags:
+        logger.info(f"Applying compatibility flags from args file for PHP {version}...")
+        env["CFLAGS"] = env.get("CFLAGS", "") + compat_flags
+        env["CXXFLAGS"] = env.get("CXXFLAGS", "") + compat_flags
+
+    if not show_logs:
+        logger.info(f"[yellow]Compiling PHP {version}...[/yellow]")
+    else:
+        logger.info("Configuring PHP within sandbox...")
+    sandbox = SandboxManager()
+    sandbox.run(configure_args, cwd=build_dir, env=env, show_logs=show_logs)
+    
+    cores = os.cpu_count() or 2
+    if show_logs:
+        logger.info(f"Compiling PHP using {cores} parallel jobs...")
+    try:
+        sandbox.run(["make", f"-j{cores}"], cwd=build_dir, env=env, show_logs=show_logs)
+    except Exception:
+        logger.warning("Parallel compilation failed (likely due to a libtool race condition). Retrying sequentially...")
+        sandbox.run(["make"], cwd=build_dir, env=env, show_logs=show_logs)
+    
+    if not show_logs:
+        logger.info(f"[green]Compiled PHP {version}[/green]")
+        logger.info(f"[yellow]Installing PHP {version}...[/yellow]")
+    else:
+        logger.info("Installing PHP...")
+    sandbox.run(["make", "install"], cwd=build_dir, env=env, show_logs=show_logs)
+    
+    if not show_logs:
+        logger.info(f"[green]Installed PHP {version}[/green]")
+        
+    add_installed_version(version, str(install_prefix), configure_args)
+    
+    logger.info(f"PHP {version} compiled and installed successfully at {install_prefix}!")
+    return install_prefix

ndev/linux/php/downloader.py

@@ -0,0 +1,58 @@
+import hashlib
+from pathlib import Path
+import httpx
+from rich.progress import Progress, TextColumn, BarColumn, DownloadColumn, TransferSpeedColumn, TimeRemainingColumn
+from ndev.common.constants import DOWNLOADS_DIR
+from ndev.common.logger import logger
+
+def calculate_sha256(filepath: Path) -> str:
+    """Calculate the SHA-256 checksum of a file."""
+    sha256 = hashlib.sha256()
+    with open(filepath, "rb") as f:
+        while chunk := f.read(8192):
+            sha256.update(chunk)
+    return sha256.hexdigest()
+
+def download_php_source(filename: str, sha256_expected: str, download_url: str) -> Path:
+    """Download PHP source tarball and verify its SHA-256 checksum."""
+    DOWNLOADS_DIR.mkdir(parents=True, exist_ok=True)
+    target_path = DOWNLOADS_DIR / filename
+    
+    if target_path.exists():
+        logger.info(f"Checking cached download: {filename}")
+        checksum = calculate_sha256(target_path)
+        if checksum == sha256_expected:
+            logger.info("Cache hit: Download is valid.")
+            return target_path
+        else:
+            logger.warning("Cache mismatch: Re-downloading source...")
+            target_path.unlink()
+            
+    logger.info(f"Downloading {filename} from {download_url}...")
+    
+    with httpx.Client() as client:
+        with client.stream("GET", download_url) as response:
+            response.raise_for_status()
+            total_size = int(response.headers.get("content-length", 0))
+            
+            with Progress(
+                TextColumn("[bold blue]{task.description}"),
+                BarColumn(),
+                DownloadColumn(),
+                TransferSpeedColumn(),
+                TimeRemainingColumn()
+            ) as progress:
+                task = progress.add_task("Downloading", total=total_size)
+                
+                with open(target_path, "wb") as f:
+                    for chunk in response.iter_bytes(chunk_size=8192):
+                        f.write(chunk)
+                        progress.update(task, advance=len(chunk))
+                        
+    checksum = calculate_sha256(target_path)
+    if sha256_expected and checksum != sha256_expected:
+        target_path.unlink()
+        raise ValueError(f"SHA-256 checksum mismatch for {filename}. Expected {sha256_expected}, got {checksum}")
+        
+    logger.info("Download completed and verified successfully.")
+    return target_path