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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ndev-stack
-Version: 0.3.9
+Version: 0.3.10
 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.9 → ndev_stack-0.3.10}/ndev/__init__.py

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

{ndev_stack-0.3.9 → ndev_stack-0.3.10}/ndev/linux/runtime/nginx_helper.py

@@ -32,7 +32,41 @@ def is_ipv6_supported() -> bool:
         return False
 
 
-def write_privileged_file(target: Path, content: str) -> None:
+def validate_sudo_password(password: str) -> bool:
+    """
+    Validate sudo password using 'sudo -v -S' and refresh sudo credential timestamp.
+    Returns True if password is valid, False otherwise.
+    """
+    if not password:
+        return False
+    try:
+        proc = subprocess.run(
+            ["sudo", "-v", "-S"],
+            input=f"{password}\n",
+            text=True,
+            capture_output=True,
+            timeout=5
+        )
+        return proc.returncode == 0
+    except Exception:
+        return False
+
+
+def check_sudo_needs_password() -> bool:
+    """
+    Check if sudo commands currently require a password prompt.
+    Returns True if sudo requires password, False if root or timestamp is active.
+    """
+    if os.geteuid() == 0:
+        return False
+    try:
+        res = subprocess.run(["sudo", "-n", "true"], capture_output=True, timeout=3)
+        return res.returncode != 0
+    except Exception:
+        return True
+
+
+def write_privileged_file(target: Path, content: str, password: Optional[str] = None) -> None:
     """
     Write content to a file, using sudo tee if current process lacks permissions.
     Ensures parent directories exist.
@@ -50,10 +84,14 @@ def write_privileged_file(target: Path, content: str) -> None:
     except (PermissionError, OSError):
         pass
 
-    # Fallback to sudo
-    subprocess.run(["sudo", "mkdir", "-p", str(target.parent)], check=True)
+    # If password supplied, ensure sudo credential timestamp is active
+    if password:
+        validate_sudo_password(password)
+
+    # Fallback to non-interactive sudo
+    subprocess.run(["sudo", "-n", "mkdir", "-p", str(target.parent)], check=True)
     subprocess.run(
-        ["sudo", "tee", str(target)],
+        ["sudo", "-n", "tee", str(target)],
         input=content,
         text=True,
         capture_output=True,
@@ -61,7 +99,7 @@ def write_privileged_file(target: Path, content: str) -> None:
     )
 
 
-def symlink_privileged(target: Path, link: Path) -> None:
+def symlink_privileged(target: Path, link: Path, password: Optional[str] = None) -> None:
     """
     Create a symbolic link, using sudo if current process lacks permissions.
     Ensures parent directory exists and removes any existing destination link/file.
@@ -81,11 +119,14 @@ def symlink_privileged(target: Path, link: Path) -> None:
     except (PermissionError, OSError):
         pass
 
-    subprocess.run(["sudo", "mkdir", "-p", str(link.parent)], check=True)
-    subprocess.run(["sudo", "ln", "-sf", str(target_resolved), str(link)], check=True)
+    if password:
+        validate_sudo_password(password)
 
+    subprocess.run(["sudo", "-n", "mkdir", "-p", str(link.parent)], check=True)
+    subprocess.run(["sudo", "-n", "ln", "-sf", str(target_resolved), str(link)], check=True)
 
-def unlink_privileged(path: Path) -> None:
+
+def unlink_privileged(path: Path, password: Optional[str] = None) -> None:
     """
     Unlink a file or symlink, falling back to sudo if needed.
     """
@@ -102,10 +143,13 @@ def unlink_privileged(path: Path) -> None:
     except (PermissionError, OSError):
         pass
 
-    subprocess.run(["sudo", "rm", "-f", str(path)], check=True)
+    if password:
+        validate_sudo_password(password)
+
+    subprocess.run(["sudo", "-n", "rm", "-f", str(path)], check=True)
 
 
-def add_to_hosts_privileged(domain: str, ip: str = "127.0.0.1") -> None:
+def add_to_hosts_privileged(domain: str, ip: str = "127.0.0.1", password: Optional[str] = None) -> None:
     """
     Safely append a domain mapping to /etc/hosts if not already present.
     """
@@ -139,9 +183,12 @@ def add_to_hosts_privileged(domain: str, ip: str = "127.0.0.1") -> None:
     except (PermissionError, OSError):
         pass
 
+    if password:
+        validate_sudo_password(password)
+
     try:
         subprocess.run(
-            ["sudo", "tee", "-a", str(hosts_file)],
+            ["sudo", "-n", "tee", "-a", str(hosts_file)],
             input=line_to_add,
             text=True,
             capture_output=True,
@@ -151,7 +198,7 @@ def add_to_hosts_privileged(domain: str, ip: str = "127.0.0.1") -> None:
         logger.warning(f"Could not update /etc/hosts via sudo: {e}")
 
 
-def remove_from_hosts_privileged(domain: str) -> None:
+def remove_from_hosts_privileged(domain: str, password: Optional[str] = None) -> None:
     """
     Remove domain entry from /etc/hosts safely.
     """
@@ -177,7 +224,7 @@ def remove_from_hosts_privileged(domain: str) -> None:
 
         if modified:
             new_content = "\n".join(new_lines) + "\n"
-            write_privileged_file(hosts_file, new_content)
+            write_privileged_file(hosts_file, new_content, password=password)
     except Exception as e:
         logger.warning(f"Could not remove {domain} from /etc/hosts: {e}")
 
@@ -223,7 +270,7 @@ def get_nginx_vhost_dirs() -> Tuple[Path, Optional[Path]]:
     return fallback, None
 
 
-def ensure_nginx_sites_enabled_included() -> None:
+def ensure_nginx_sites_enabled_included(password: Optional[str] = None) -> None:
     """
     Ensure Nginx includes virtual hosts from /etc/nginx/sites-enabled.
     If /etc/nginx/nginx.conf already includes sites-enabled, no change is made.
@@ -245,7 +292,7 @@ def ensure_nginx_sites_enabled_included() -> None:
     )
     try:
         if not bridge_conf.exists() or bridge_conf.read_text(encoding="utf-8", errors="ignore") != bridge_content:
-            write_privileged_file(bridge_conf, bridge_content)
+            write_privileged_file(bridge_conf, bridge_content, password=password)
     except Exception as e:
         logger.debug(f"Could not create sites-enabled bridge configuration: {e}")
 
@@ -377,7 +424,7 @@ server {{
 """
 
 
-def reload_nginx() -> bool:
+def reload_nginx(password: Optional[str] = None) -> bool:
     """
     Reload Nginx configuration safely using available init system or nginx CLI.
     """
@@ -395,7 +442,9 @@ def reload_nginx() -> bool:
         return False
 
     if os.geteuid() != 0:
-        cmd = ["sudo"] + cmd
+        if password:
+            validate_sudo_password(password)
+        cmd = ["sudo", "-n"] + cmd
 
     try:
         res = subprocess.run(cmd, capture_output=True, timeout=10)
@@ -451,7 +500,7 @@ def get_vhost(domain: str) -> Optional[Dict[str, Any]]:
     return None
 
 
-def remove_vhost(domain: str) -> bool:
+def remove_vhost(domain: str, password: Optional[str] = None) -> bool:
     """Remove vhost configuration file(s), symlinks, and /etc/hosts entry."""
     clean_domain = re.sub(r"^https?://", "", domain.strip().lower()).rstrip("/")
     removed = False
@@ -459,7 +508,7 @@ def remove_vhost(domain: str) -> bool:
         conf_file = sdir / f"{clean_domain}.conf"
         if conf_file.exists() or conf_file.is_symlink():
             try:
-                unlink_privileged(conf_file)
+                unlink_privileged(conf_file, password=password)
                 removed = True
             except Exception as e:
                 logger.warning(f"Could not remove {conf_file}: {e}")
@@ -474,9 +523,9 @@ def remove_vhost(domain: str) -> bool:
                 pass
 
     # Remove from /etc/hosts
-    remove_from_hosts_privileged(clean_domain)
+    remove_from_hosts_privileged(clean_domain, password=password)
 
     # Reload nginx
-    reload_nginx()
+    reload_nginx(password=password)
 
     return removed

{ndev_stack-0.3.9 → ndev_stack-0.3.10}/ndev/linux/tui.py

@@ -248,13 +248,53 @@ def _pick_directory_os(initial_path: Optional[str] = None) -> Optional[str]:
     return None
 
 
+class SudoPasswordModal(ModalScreen[Optional[str]]):
+    """Modal dialog to prompt for administrator (sudo) password when needed."""
+
+    def __init__(self, action_name: str = "This operation") -> None:
+        super().__init__()
+        self.action_name = action_name
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="modal-dialog"):
+            yield Label("🔐 Administrator Authentication", id="modal-title")
+            yield Label(f"{self.action_name} requires administrator privileges.", classes="modal-label")
+            yield Label("Enter your sudo password:", classes="modal-label")
+            yield Input(password=True, placeholder="Password", id="input-sudo-pass", classes="modal-input")
+            with Horizontal(id="modal-buttons"):
+                yield Button("Authenticate", variant="primary", id="btn-auth-confirm")
+                yield Button("Cancel", variant="default", id="btn-auth-cancel")
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        self.query_one("#btn-auth-confirm", Button).press()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "btn-auth-confirm":
+            pwd_input = self.query_one("#input-sudo-pass", Input)
+            pwd = pwd_input.value
+            if not pwd:
+                self.notify("Password is required.", severity="error")
+                pwd_input.focus()
+                return
+            from ndev.linux.runtime.nginx_helper import validate_sudo_password
+            if not validate_sudo_password(pwd):
+                self.notify("Incorrect administrator password. Please try again.", severity="error")
+                pwd_input.value = ""
+                pwd_input.focus()
+                return
+            self.dismiss(pwd)
+        else:
+            self.dismiss(None)
+
+
 class CreateVhostModal(ModalScreen[Optional[dict]]):
     """Modal dialog to create a new virtual host with local SSL on Linux."""
 
-    def __init__(self, installed_phps: list[str], default_php: Optional[str] = None) -> None:
+    def __init__(self, installed_phps: list[str], default_php: Optional[str] = None, needs_sudo: bool = False) -> None:
         super().__init__()
         self.installed_phps = installed_phps
         self.default_php = default_php or (installed_phps[0] if installed_phps else "8.4")
+        self.needs_sudo = needs_sudo
         self._user_edited_root = False
 
     def compose(self) -> ComposeResult:
@@ -273,10 +313,23 @@ class CreateVhostModal(ModalScreen[Optional[dict]]):
             yield Label("PHP Version:", classes="modal-label")
             yield Select(php_options, value=initial_php, id="select-vhost-php", classes="modal-input")
             yield Checkbox("Enable Local SSL (HTTPS with mkcert)", value=True, id="chk-vhost-ssl")
+
+            if self.needs_sudo:
+                yield Label("🔐 Administrator (sudo) Password:", classes="modal-label")
+                yield Input(
+                    placeholder="Enter sudo password for /etc/nginx & /etc/hosts",
+                    password=True,
+                    id="input-vhost-password",
+                    classes="modal-input"
+                )
+
             with Horizontal(id="modal-buttons"):
                 yield Button("Create VHost", variant="success", id="btn-modal-create")
                 yield Button("Cancel", variant="default", id="btn-modal-cancel")
 
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        self.query_one("#btn-modal-create", Button).press()
+
     def on_input_changed(self, event: Input.Changed) -> None:
         if event.input.id == "input-vhost-domain":
             domain = event.value.strip()
@@ -318,11 +371,27 @@ class CreateVhostModal(ModalScreen[Optional[dict]]):
                 self.notify("Document root directory is required.", severity="error")
                 return
 
+            password = None
+            if self.needs_sudo:
+                pwd_input = self.query_one("#input-vhost-password", Input)
+                password = pwd_input.value
+                if not password:
+                    self.notify("Administrator (sudo) password is required.", severity="error")
+                    pwd_input.focus()
+                    return
+                from ndev.linux.runtime.nginx_helper import validate_sudo_password
+                if not validate_sudo_password(password):
+                    self.notify("Incorrect administrator password. Please try again.", severity="error")
+                    pwd_input.value = ""
+                    pwd_input.focus()
+                    return
+
             self.dismiss({
                 "domain": domain,
                 "root": root,
                 "php": php_ver,
                 "ssl": bool(ssl),
+                "password": password,
             })
         else:
             self.dismiss(None)
@@ -443,6 +512,16 @@ class NdevDashboard(App):
         self._updating_selects = False
         self._available_logs: Dict[str, Path] = {}
         self._selected_service_key: Optional[str] = None
+        self._sudo_password: Optional[str] = None
+
+    def _needs_sudo(self) -> bool:
+        """Check if elevated privileges are needed and require a password prompt."""
+        from ndev.linux.runtime.nginx_helper import check_sudo_needs_password, validate_sudo_password
+        if not check_sudo_needs_password():
+            return False
+        if self._sudo_password and validate_sudo_password(self._sudo_password):
+            return False
+        return True
 
     def compose(self) -> ComposeResult:
         yield Header(show_clock=True)
@@ -959,18 +1038,25 @@ class NdevDashboard(App):
     async def action_reload_nginx(self) -> None:
         """Reload Nginx configuration."""
         self.log_message("[bold blue]Reloading Nginx configuration...[/bold blue]")
-        try:
-            def _reload():
-                if shutil.which("systemctl"):
-                    subprocess.run(["sudo", "systemctl", "reload", "nginx"], check=True)
-                else:
-                    subprocess.run(["sudo", "service", "nginx", "reload"], check=True)
-            await asyncio.to_thread(_reload)
-            self.log_message("[bold green]✓ Nginx configuration reloaded successfully.[/bold green]")
-            self.notify("Nginx reloaded.", severity="information")
-        except Exception as e:
-            self.log_message(f"[bold red]✗ Failed to reload Nginx: {e}[/bold red]")
-            self.notify(f"Nginx reload failed: {e}", severity="error")
+
+        def _do_reload(pwd: Optional[str] = None) -> None:
+            from ndev.linux.runtime.nginx_helper import reload_nginx
+            ok = reload_nginx(password=pwd or self._sudo_password)
+            if ok:
+                self.log_message("[bold green]✓ Nginx configuration reloaded successfully.[/bold green]")
+                self.notify("Nginx reloaded.", severity="information")
+            else:
+                self.log_message("[bold red]✗ Failed to reload Nginx.[/bold red]")
+                self.notify("Nginx reload failed.", severity="error")
+
+        if self._needs_sudo():
+            def _on_pwd(pwd: Optional[str]) -> None:
+                if pwd:
+                    self._sudo_password = pwd
+                    asyncio.create_task(asyncio.to_thread(_do_reload, pwd))
+            self.push_screen(SudoPasswordModal("Reloading Nginx"), _on_pwd)
+        else:
+            await asyncio.to_thread(_do_reload, self._sudo_password)
 
     @work(exclusive=True)
     async def action_check_upgrades(self) -> None:
@@ -1098,12 +1184,15 @@ class NdevDashboard(App):
 
         def _on_modal_result(res: Optional[dict]) -> None:
             if res:
-                self._create_vhost_worker(res["domain"], res["root"], res["php"], res["ssl"])
+                pwd = res.get("password") or self._sudo_password
+                if pwd:
+                    self._sudo_password = pwd
+                self._create_vhost_worker(res["domain"], res["root"], res["php"], res["ssl"], password=pwd)
 
-        self.push_screen(CreateVhostModal(installed, curr), _on_modal_result)
+        self.push_screen(CreateVhostModal(installed, curr, needs_sudo=self._needs_sudo()), _on_modal_result)
 
     @work(exclusive=True)
-    async def _create_vhost_worker(self, domain: str, root: str, php_ver: str, ssl: bool) -> None:
+    async def _create_vhost_worker(self, domain: str, root: str, php_ver: str, ssl: bool, password: Optional[str] = None) -> None:
         self.query_one(TabbedContent).active = "tab-logs"
         self.log_message(f"[bold blue]Creating virtual host '{domain}' (PHP {php_ver}, SSL={ssl})...[/bold blue]")
         self.notify(f"Creating vhost {domain}...", severity="information")
@@ -1122,7 +1211,7 @@ class NdevDashboard(App):
 
             vhost_dir, enabled_dir = get_nginx_vhost_dirs()
             if enabled_dir:
-                ensure_nginx_sites_enabled_included()
+                ensure_nginx_sites_enabled_included(password=password)
 
             conf_file = vhost_dir / f"{domain}.conf"
 
@@ -1142,16 +1231,16 @@ class NdevDashboard(App):
                 cert_path=cert_path,
                 key_path=key_path,
             )
-            write_privileged_file(conf_file, tpl)
+            write_privileged_file(conf_file, tpl, password=password)
             if enabled_dir and enabled_dir != vhost_dir:
                 link = enabled_dir / f"{domain}.conf"
-                symlink_privileged(conf_file, link)
+                symlink_privileged(conf_file, link, password=password)
 
             # Add /etc/hosts entry
-            add_to_hosts_privileged(domain)
+            add_to_hosts_privileged(domain, password=password)
 
             # Reload Nginx
-            reload_nginx()
+            reload_nginx(password=password)
             return str(conf_file)
 
         try:
@@ -1177,21 +1266,32 @@ class NdevDashboard(App):
         row_key = vhost_table.coordinate_to_cell_key((vhost_table.cursor_row, 0)).row_key
         domain = str(row_key.value)
 
+        def _do_delete(pwd: Optional[str] = None) -> None:
+            if pwd:
+                self._sudo_password = pwd
+            self._delete_vhost_worker(domain, password=pwd or self._sudo_password)
+
         def _on_confirm(confirmed: bool) -> None:
             if confirmed:
-                self._delete_vhost_worker(domain)
+                if self._needs_sudo():
+                    self.push_screen(
+                        SudoPasswordModal(f"Deleting virtual host '{domain}'"),
+                        lambda pwd: _do_delete(pwd) if pwd else None
+                    )
+                else:
+                    _do_delete(self._sudo_password)
 
         msg = f"Are you sure you want to delete virtual host '{domain}'?\n\nThis will remove its Nginx configuration, SSL certificates, and hosts entry."
         self.push_screen(ConfirmActionModal("Delete Virtual Host", msg, confirm_label="Delete VHost", variant="error"), _on_confirm)
 
     @work(exclusive=True)
-    async def _delete_vhost_worker(self, domain: str) -> None:
+    async def _delete_vhost_worker(self, domain: str, password: Optional[str] = None) -> None:
         self.log_message(f"[bold yellow]Deleting virtual host '{domain}'...[/bold yellow]")
         self.notify(f"Deleting vhost {domain}...", severity="information")
 
         def _do() -> None:
             from ndev.linux.runtime.nginx_helper import remove_vhost
-            remove_vhost(domain)
+            remove_vhost(domain, password=password)
 
         try:
             await asyncio.to_thread(_do)
@@ -1201,6 +1301,8 @@ class NdevDashboard(App):
         except Exception as e:
             self.log_message(f"[bold red]✗ Failed to delete virtual host {domain}: {e}[/bold red]")
             self.notify(f"Delete failed: {e}", severity="error")
+            self.log_message(f"[bold red]✗ Failed to delete virtual host {domain}: {e}[/bold red]")
+            self.notify(f"Delete failed: {e}", severity="error")
 
     def action_install_php(self) -> None:
         """Open modal dialog to install a new PHP runtime."""

{ndev_stack-0.3.9 → ndev_stack-0.3.10}/ndev_stack.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ndev-stack
-Version: 0.3.9
+Version: 0.3.10
 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.9 → ndev_stack-0.3.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ndev-stack"
-version = "0.3.9"
+version = "0.3.10"
 description = "Cross-platform developer stack manager for PHP, FastCGI/PHP-FPM, MariaDB, Redis, PostgreSQL, MongoDB, Nginx, SSL, and Mailpit on Linux and Windows"
 readme = "README.md"
 requires-python = ">=3.10"

{ndev_stack-0.3.9 → ndev_stack-0.3.10}/tests/test_opensuse_compat.py

@@ -233,6 +233,28 @@ class TestNginxHelper(unittest.TestCase):
             self.assertFalse(link_target.exists())
             self.assertFalse(link_target.is_symlink())
 
+    def test_validate_sudo_password(self):
+        with patch("subprocess.run") as mock_run:
+            mock_run.return_value = unittest.mock.MagicMock(returncode=0)
+            self.assertTrue(nginx_helper.validate_sudo_password("valid_pwd"))
+
+            mock_run.return_value = unittest.mock.MagicMock(returncode=1)
+            self.assertFalse(nginx_helper.validate_sudo_password("invalid_pwd"))
+
+            self.assertFalse(nginx_helper.validate_sudo_password(""))
+
+    def test_check_sudo_needs_password(self):
+        with patch("os.geteuid", return_value=0):
+            self.assertFalse(nginx_helper.check_sudo_needs_password())
+
+        with patch("os.geteuid", return_value=1000):
+            with patch("subprocess.run") as mock_run:
+                mock_run.return_value = unittest.mock.MagicMock(returncode=0)
+                self.assertFalse(nginx_helper.check_sudo_needs_password())
+
+                mock_run.return_value = unittest.mock.MagicMock(returncode=1)
+                self.assertTrue(nginx_helper.check_sudo_needs_password())
+
     def test_fastcgi_snippet_opensuse(self):
         with patch.object(Path, "exists", autospec=True) as mock_exists:
             def side_effect_exists(p):