ndev-stack 0.3.8__tar.gz → 0.3.9__tar.gz

{ndev_stack-0.3.8 → ndev_stack-0.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ndev-stack
-Version: 0.3.8
+Version: 0.3.9
 Summary: Cross-platform developer stack manager for PHP, FastCGI/PHP-FPM, MariaDB, Redis, PostgreSQL, MongoDB, Nginx, SSL, and Mailpit on Linux and Windows
 Author-email: Ankit Karan <ankit.karan99@gmail.com>
 Project-URL: Homepage, https://github.com/ankitkaran99/ndev

{ndev_stack-0.3.8 → ndev_stack-0.3.9}/ndev/__init__.py

@@ -1,7 +1,7 @@
 """
 ndev: Fast, cross-platform PHP developer environment for Windows and Linux.
 """
-__version__ = "0.3.8"
+__version__ = "0.3.9"
 
 from . import common as common
 from .common.logger import logger as logger

{ndev_stack-0.3.8 → ndev_stack-0.3.9}/ndev/linux/commands/vhost.py

@@ -7,11 +7,14 @@ import typer
 from pathlib import Path
 from rich.console import Console
 from ndev.common.logger import logger
+from ndev.common.utils import which_binary, resolve_installed_version
 from typing import Optional
 
 console = Console()
 
-def chown_to_sudo_user(path: Path):
+
+def chown_to_sudo_user(path: Path) -> None:
+    """Change ownership of a path to the user who invoked sudo."""
     sudo_user = os.environ.get("SUDO_USER")
     if sudo_user:
         try:
@@ -21,39 +24,73 @@ def chown_to_sudo_user(path: Path):
         except Exception:
             pass
 
+
+def find_mkcert_binary() -> Optional[str]:
+    """Find mkcert executable in system PATH or user local bin."""
+    found = which_binary("mkcert") or shutil.which("mkcert")
+    if found:
+        return found
+
+    candidates = [
+        Path.home() / ".local" / "bin" / "mkcert",
+        Path("/usr/local/bin/mkcert"),
+        Path("/usr/bin/mkcert"),
+    ]
+    sudo_user = os.environ.get("SUDO_USER")
+    if sudo_user:
+        try:
+            import pwd
+            user_home = Path(pwd.getpwnam(sudo_user).pw_dir)
+            candidates.insert(0, user_home / ".local" / "bin" / "mkcert")
+        except Exception:
+            pass
+
+    for c in candidates:
+        if c.exists() and os.access(c, os.X_OK):
+            return str(c)
+
+    return None
+
+
 def generate_local_cert(domain: str, certs_dir: Path) -> tuple[Path, Path]:
+    """Generate SSL certificate and private key using mkcert."""
     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)
-    
+
+    mkcert_bin = find_mkcert_binary()
+    if not mkcert_bin:
+        raise FileNotFoundError("mkcert binary not found in PATH or ~/.local/bin")
+
     sudo_user = os.environ.get("SUDO_USER")
-    if sudo_user:
+    if sudo_user and os.geteuid() == 0:
         cmd = [
             "sudo", "-u", sudo_user,
-            "mkcert",
+            mkcert_bin,
             "-cert-file", str(cert_path),
             "-key-file", str(key_path),
             domain, f"*.{domain}"
         ]
     else:
         cmd = [
-            "mkcert",
+            mkcert_bin,
             "-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:
@@ -64,6 +101,7 @@ def get_user_ndev_dir() -> Path:
             pass
     return Path(os.path.expanduser("~/.ndev"))
 
+
 def get_installed_php_versions() -> list[dict]:
     installed = []
     ndev_dir = get_user_ndev_dir()
@@ -72,7 +110,6 @@ def get_installed_php_versions() -> list[dict]:
         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]}"
@@ -81,20 +118,19 @@ def get_installed_php_versions() -> list[dict]:
                     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"]))
@@ -102,11 +138,14 @@ def get_installed_php_versions() -> list[dict]:
         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")
+    ssl: Optional[bool] = typer.Option(None, "--ssl/--no-ssl", help="Enable SSL/HTTPS with local certificate generation"),
+    cert: Optional[str] = typer.Option(None, "--cert", help="Path to existing SSL certificate file"),
+    key: Optional[str] = typer.Option(None, "--key", help="Path to existing SSL private key file"),
 ):
     """Create Nginx Virtual Host config, map to hosts file, and reload Nginx."""
     if not domain:
@@ -114,7 +153,7 @@ def vhost_cmd(
     if not domain:
         logger.error("Domain is required.")
         raise typer.Exit(code=1)
-        
+
     if not root:
         sudo_user = os.environ.get("SUDO_USER")
         if sudo_user:
@@ -130,7 +169,7 @@ def vhost_cmd(
     if not root:
         logger.error("Project Root is required.")
         raise typer.Exit(code=1)
-        
+
     root_path = Path(root).resolve()
     if not root_path.exists():
         root_path.mkdir(parents=True, exist_ok=True)
@@ -142,30 +181,52 @@ def vhost_cmd(
             encoding="utf-8"
         )
         chown_to_sudo_user(index_php)
-        
+
     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":
+        if php_path.suffix == ".sock":
             selected_sock = php_path
+            # Find matching version from socket name
+            for item in installed_phps:
+                if item["socket"].name == php_path.name or item["socket"] == php_path:
+                    selected_ver = item["version"]
+                    break
+            if not selected_ver:
+                m = re.search(r"\d+", php_path.stem)
+                if m:
+                    digits = m.group(0)
+                    for item in installed_phps:
+                        item_mm = item["version"].replace(".", "")[:len(digits)]
+                        if item_mm == digits:
+                            selected_ver = item["version"]
+                            break
         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:
+                resolved = resolve_installed_version(clean_php)
+                if resolved:
+                    for item in installed_phps:
+                        if item["version"] == resolved or item["label"] == resolved:
+                            selected_sock = item["socket"]
+                            selected_ver = item["version"]
+                            break
+
             if not selected_sock:
                 try:
                     idx = int(php)
@@ -174,7 +235,7 @@ def vhost_cmd(
                         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)
@@ -191,10 +252,10 @@ def vhost_cmd(
             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)
@@ -205,22 +266,27 @@ def vhost_cmd(
                 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("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 cert and key and Path(cert).exists() and Path(key).exists():
+            cert_path = Path(cert)
+            key_path = Path(key)
+        else:
+            mkcert_bin = find_mkcert_binary()
+            if not mkcert_bin:
+                logger.error("mkcert binary not found. Please install mkcert to generate local certificates ('ndev upgrade mkcert').")
+                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("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 = [
@@ -234,31 +300,44 @@ def vhost_cmd(
             "--root",
             root,
             "--php",
-            str(selected_sock)
+            str(selected_sock),
         ]
         if ssl:
             cmd.append("--ssl")
+            if cert_path and key_path:
+                cmd.extend(["--cert", str(cert_path), "--key", str(key_path)])
         else:
             cmd.append("--no-ssl")
-            
+
         try:
             res = subprocess.run(cmd)
             raise typer.Exit(code=res.returncode)
         except KeyboardInterrupt:
             raise typer.Exit(code=1)
-            
-    from ndev.linux.runtime.nginx_helper import get_nginx_vhost_dirs, generate_vhost_config
+
+    from ndev.linux.runtime.nginx_helper import (
+        get_nginx_vhost_dirs,
+        generate_vhost_config,
+        ensure_nginx_sites_enabled_included,
+        add_to_hosts_privileged,
+        reload_nginx,
+    )
 
     vhost_dir, enabled_dir = get_nginx_vhost_dirs()
-    hosts_file = Path("/etc/hosts")
-    
-    if not vhost_dir.exists():
-        try:
-            vhost_dir.mkdir(parents=True, exist_ok=True)
-        except Exception:
-            logger.error(f"Nginx configuration directory not found and could not be created: {vhost_dir}")
-            raise typer.Exit(code=1)
-        
+
+    # Ensure target configuration directories exist
+    try:
+        vhost_dir.mkdir(parents=True, exist_ok=True)
+        if enabled_dir:
+            enabled_dir.mkdir(parents=True, exist_ok=True)
+    except Exception as e:
+        logger.error(f"Failed to create Nginx configuration directories: {e}")
+        raise typer.Exit(code=1)
+
+    # Ensure sites-enabled is bridged into nginx.conf if used
+    if enabled_dir:
+        ensure_nginx_sites_enabled_included()
+
     conf_file = vhost_dir / f"{domain}.conf"
     config_template = generate_vhost_config(
         domain=domain,
@@ -269,45 +348,39 @@ def vhost_cmd(
         key_path=key_path,
     )
 
+    enabled_link = None
     try:
-        conf_file.write_text(config_template)
-        enabled_link = None
+        conf_file.write_text(config_template, encoding="utf-8")
+
         if enabled_dir and enabled_dir != vhost_dir:
             enabled_link = enabled_dir / 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)
+            enabled_link.unlink(missing_ok=True)
+            enabled_link.symlink_to(conf_file.resolve())
+
+        # Update /etc/hosts
+        add_to_hosts_privileged(domain)
+
+        # Test Nginx configuration before reloading
+        nginx_bin = which_binary("nginx") or shutil.which("nginx") or "nginx"
+        res = subprocess.run([nginx_bin, "-t"], capture_output=True, text=True)
         if res.returncode != 0:
             logger.error(f"Nginx config test failed:\n{res.stderr}")
             if enabled_link:
                 enabled_link.unlink(missing_ok=True)
             conf_file.unlink(missing_ok=True)
             raise typer.Exit(code=1)
-            
-        if shutil.which("systemctl"):
-            subprocess.run(["systemctl", "reload", "nginx"], check=True)
-        elif shutil.which("service"):
-            subprocess.run(["service", "nginx", "reload"], check=True)
-        
+
+        # Reload Nginx service
+        reload_nginx()
+
         console.print("\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 enabled_link:
+            console.print(f"Symlink     : {enabled_link}")
         if ssl:
             console.print(f"SSL Cert    : {cert_path}")
             console.print(f"SSL Key     : {key_path}")
@@ -315,6 +388,9 @@ def vhost_cmd(
         else:
             console.print(f"\nOpen: http://{domain}")
     except Exception as e:
+        if enabled_link:
+            enabled_link.unlink(missing_ok=True)
+        conf_file.unlink(missing_ok=True)
         logger.error(f"Failed to create virtual host: {e}")
         raise typer.Exit(code=1)
 
@@ -382,5 +458,3 @@ def vhost_remove_cmd(
         console.print(f"[bold green]✓ Removed virtual host '{clean_domain}'.[/bold green]")
     else:
         console.print(f"[yellow]Virtual host '{clean_domain}' not found or could not be removed.[/yellow]")
-
-