ndev-stack 0.1.0__py3-none-any.whl

ndev/linux/cli.py

@@ -0,0 +1,235 @@
+import typer
+from ndev.common.logger import logger
+from ndev.common.config import init_layout
+
+app = typer.Typer(
+    help="ndev: Compile, install, and manage isolated PHP-FPM versions on Debian.",
+    no_args_is_help=True
+)
+
+ext_app = typer.Typer(
+    help="Manage PHP extensions for installed versions.",
+    no_args_is_help=True
+)
+app.add_typer(ext_app, name="ext")
+
+# Register commands
+from ndev.linux.commands.install import install_cmd
+app.command("install")(install_cmd)
+
+from ndev.linux.commands.uninstall import uninstall_cmd
+app.command("uninstall")(uninstall_cmd)
+
+from ndev.linux.commands.start import start_cmd
+app.command("start")(start_cmd)
+
+from ndev.linux.commands.stop import stop_cmd
+app.command("stop")(stop_cmd)
+
+from ndev.linux.commands.restart import restart_cmd
+app.command("restart")(restart_cmd)
+
+from ndev.linux.commands.reload import reload_cmd
+app.command("reload")(reload_cmd)
+
+from ndev.linux.commands.status import status_cmd
+app.command("status")(status_cmd)
+
+from ndev.linux.commands.list import list_cmd
+app.command("list")(list_cmd)
+
+from ndev.linux.commands.current import current_cmd
+app.command("current")(current_cmd)
+
+from ndev.linux.commands.use import use_cmd
+app.command("use")(use_cmd)
+
+from ndev.linux.commands.available import available_cmd
+app.command("available")(available_cmd)
+
+from ndev.linux.commands.doctor import doctor_cmd
+app.command("doctor")(doctor_cmd)
+
+from ndev.linux.commands.update import update_cmd
+app.command("update")(update_cmd)
+
+from ndev.linux.commands.clean import clean_cmd
+app.command("clean")(clean_cmd)
+
+from ndev.linux.commands.logs import logs_cmd
+app.command("logs")(logs_cmd)
+
+from ndev.linux.commands.grok import grok_cmd
+app.command("grok")(grok_cmd)
+
+from ndev.linux.commands.vhost import vhost_cmd
+app.command("vhost")(vhost_cmd)
+
+from ndev.linux.commands.ctl import ctl_cmd
+app.command("ctl")(ctl_cmd)
+
+from ndev.linux.commands.setup import setup_cmd
+app.command("setup")(setup_cmd)
+
+from ndev.linux.commands.upgrade import app as upgrade_app
+app.add_typer(upgrade_app, name="upgrade")
+
+from ndev.linux.commands.db import db_app
+app.add_typer(db_app, name="db")
+
+from ndev.linux.commands.mailpit import mailpit_app
+app.add_typer(mailpit_app, name="mailpit")
+
+@app.command("ui")
+def ui_cmd():
+    """Launch the interactive Textual TUI dashboard."""
+    from ndev.tui import run_dashboard
+    run_dashboard()
+
+@app.command("tui", hidden=True)
+def tui_cmd():
+    """Alias for ui."""
+    from ndev.tui import run_dashboard
+    run_dashboard()
+
+@app.command("dashboard", hidden=True)
+def dashboard_cmd():
+    """Alias for ui."""
+    from ndev.tui import run_dashboard
+    run_dashboard()
+
+@app.command("shell")
+def shell():
+    """Enter the interactive bubblewrap build environment shell."""
+    from ndev.linux.chroot.shell import enter_sandbox_shell
+    enter_sandbox_shell()
+
+# Extension command implementations
+@ext_app.command("list")
+def ext_list(version: str = typer.Argument(None, help="PHP version (e.g. 8.4.12)")):
+    """List loaded extensions for a PHP version."""
+    from ndev.linux.php.extensions import list_extensions
+    if not version:
+        from ndev.common.utils import get_version_or_prompt
+        version = get_version_or_prompt(version, "PHP version")
+    if not version:
+        logger.error("PHP version is required.")
+        raise typer.Exit(code=1)
+    try:
+        exts = list_extensions(version)
+        for ext in exts:
+            print(ext)
+    except Exception as e:
+        logger.error(f"Error listing extensions: {e}")
+        raise typer.Exit(code=1)
+
+@ext_app.command("install")
+def ext_install(
+    ext_name: str = typer.Argument(None, help="Extension name (e.g. redis)"),
+    version: str = typer.Argument(None, help="PHP version (e.g. 8.4.12)"),
+    show_logs: bool = typer.Option(
+        False,
+        "--show-logs",
+        "-s",
+        help="Show verbose compilation and installation logs"
+    )
+):
+    """Install and enable a PECL extension."""
+    from ndev.linux.php.extensions import install_extension
+    if not ext_name:
+        ext_name = typer.prompt("Extension name (e.g. redis)").strip()
+    if not ext_name:
+        logger.error("Extension name is required.")
+        raise typer.Exit(code=1)
+    if not version:
+        from ndev.common.utils import get_version_or_prompt
+        version = get_version_or_prompt(version, "PHP version")
+    if not version:
+        logger.error("PHP version is required.")
+        raise typer.Exit(code=1)
+    try:
+        install_extension(version, ext_name, show_logs=show_logs)
+    except Exception as e:
+        logger.error(f"Error installing extension: {e}")
+        raise typer.Exit(code=1)
+
+@ext_app.command("uninstall")
+def ext_uninstall(
+    ext_name: str = typer.Argument(None, help="Extension name (e.g. redis)"),
+    version: str = typer.Argument(None, help="PHP version (e.g. 8.4.12)")
+):
+    """Disable/uninstall an extension."""
+    from ndev.linux.php.extensions import disable_extension
+    if not ext_name:
+        ext_name = typer.prompt("Extension name (e.g. redis)").strip()
+    if not ext_name:
+        logger.error("Extension name is required.")
+        raise typer.Exit(code=1)
+    if not version:
+        from ndev.common.utils import get_version_or_prompt
+        version = get_version_or_prompt(version, "PHP version")
+    if not version:
+        logger.error("PHP version is required.")
+        raise typer.Exit(code=1)
+    try:
+        disable_extension(version, ext_name)
+    except Exception as e:
+        logger.error(f"Error uninstalling extension: {e}")
+        raise typer.Exit(code=1)
+
+@ext_app.command("enable")
+def ext_enable(
+    ext_name: str = typer.Argument(None, help="Extension name (e.g. redis)"),
+    version: str = typer.Argument(None, help="PHP version (e.g. 8.4.12)")
+):
+    """Enable an installed extension."""
+    from ndev.linux.php.extensions import enable_extension
+    if not ext_name:
+        ext_name = typer.prompt("Extension name (e.g. redis)").strip()
+    if not ext_name:
+        logger.error("Extension name is required.")
+        raise typer.Exit(code=1)
+    if not version:
+        from ndev.common.utils import get_version_or_prompt
+        version = get_version_or_prompt(version, "PHP version")
+    if not version:
+        logger.error("PHP version is required.")
+        raise typer.Exit(code=1)
+    try:
+        enable_extension(version, ext_name)
+    except Exception as e:
+        logger.error(f"Error enabling extension: {e}")
+        raise typer.Exit(code=1)
+
+@ext_app.command("disable")
+def ext_disable(
+    ext_name: str = typer.Argument(None, help="Extension name (e.g. redis)"),
+    version: str = typer.Argument(None, help="PHP version (e.g. 8.4.12)")
+):
+    """Disable an extension."""
+    from ndev.linux.php.extensions import disable_extension
+    if not ext_name:
+        ext_name = typer.prompt("Extension name (e.g. redis)").strip()
+    if not ext_name:
+        logger.error("Extension name is required.")
+        raise typer.Exit(code=1)
+    if not version:
+        from ndev.common.utils import get_version_or_prompt
+        version = get_version_or_prompt(version, "PHP version")
+    if not version:
+        logger.error("PHP version is required.")
+        raise typer.Exit(code=1)
+    try:
+        disable_extension(version, ext_name)
+    except Exception as e:
+        logger.error(f"Error disabling extension: {e}")
+        raise typer.Exit(code=1)
+
+
+@app.callback()
+def main():
+    # Initialize the folder structure in ~/.ndev
+    init_layout()
+
+if __name__ == "__main__":
+    app()

ndev/linux/commands/available.py

@@ -0,0 +1,38 @@
+import typer
+from rich.console import Console
+from rich.table import Table
+from ndev.common.github import fetch_releases
+from ndev.common.logger import logger
+
+console = Console()
+
+def available_cmd():
+    """List all available PHP versions from php.net."""
+    logger.info("Fetching available PHP versions from php.net...")
+    
+    releases_8 = fetch_releases(8)
+    releases_7 = fetch_releases(7)
+    
+    all_releases = {**releases_8, **releases_7}
+    
+    if not all_releases:
+        logger.error("Could not fetch available releases. Check your network connection.")
+        raise typer.Exit(code=1)
+        
+    from packaging.version import parse as parse_version
+    sorted_versions = sorted(all_releases.keys(), key=parse_version, reverse=True)
+    
+    table = Table(title="Available PHP Releases")
+    table.add_column("Version", style="bold cyan")
+    table.add_column("Release Date")
+    table.add_column("Security Release")
+    
+    for v in sorted_versions:
+        data = all_releases[v]
+        date = data.get("date", "N/A")
+        tags = data.get("tags", [])
+        is_security = "Yes" if "security" in tags else "No"
+        
+        table.add_row(v, date, is_security)
+        
+    console.print(table)

ndev/linux/commands/clean.py

@@ -0,0 +1,25 @@
+import shutil
+import typer
+from ndev.common.constants import BUILDS_DIR, DOWNLOADS_DIR
+from ndev.common.logger import logger
+
+def clean_cmd(
+    builds: bool = typer.Option(True, "--builds/--no-builds", help="Clean extracted build source folders"),
+    downloads: bool = typer.Option(False, "--downloads", help="Clean cached download tarballs")
+):
+    """Clean up build files and optionally downloaded archives to free disk space."""
+    try:
+        if builds and BUILDS_DIR.exists():
+            logger.info(f"Cleaning build directory: {BUILDS_DIR}")
+            shutil.rmtree(BUILDS_DIR)
+            BUILDS_DIR.mkdir()
+            
+        if downloads and DOWNLOADS_DIR.exists():
+            logger.info(f"Cleaning downloads cache: {DOWNLOADS_DIR}")
+            shutil.rmtree(DOWNLOADS_DIR)
+            DOWNLOADS_DIR.mkdir()
+            
+        logger.info("Cleanup completed successfully.")
+    except Exception as e:
+        logger.error(f"Cleanup failed: {e}")
+        raise typer.Exit(code=1)

ndev/linux/commands/ctl.py

@@ -0,0 +1,192 @@
+import os
+import sys
+import re
+import subprocess
+import shutil
+import typer
+from pathlib import Path
+from rich.console import Console
+from rich.table import Table
+from ndev.common.logger import logger
+
+console = Console()
+
+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 service_exists(service: str) -> bool:
+    if service == "pma":
+        return True
+    if service.startswith("ndev-"):
+        version = service[5:]
+        return (get_user_ndev_dir() / "php" / version).exists()
+        
+    if shutil.which("systemctl"):
+        res = subprocess.run(["systemctl", "list-unit-files", f"{service}.service"], capture_output=True, text=True)
+        return service in res.stdout
+    else:
+        return Path(f"/etc/init.d/{service}").exists()
+
+def service_status(service: str) -> str:
+    if not service_exists(service):
+        return "NOT INSTALLED"
+        
+    if service == "pma":
+        from ndev.linux.runtime.pma import get_pma_status
+        st = get_pma_status()
+        if st["running"]:
+            return "RUNNING"
+        elif not st["installed"]:
+            return "NOT INSTALLED"
+        else:
+            return "STOPPED"
+
+    if service.startswith("ndev-"):
+        version = service[5:]
+        script_path = sys.argv[0]
+        res = subprocess.run([sys.executable, script_path, "status", version], capture_output=True, text=True)
+        if "Running" in res.stdout:
+            return "RUNNING"
+        else:
+            return "STOPPED"
+            
+    if shutil.which("systemctl"):
+        res = subprocess.run(["systemctl", "is-active", "--quiet", service])
+        return "RUNNING" if res.returncode == 0 else "STOPPED"
+    return "UNKNOWN"
+
+def get_php_versions() -> list[str]:
+    versions = []
+    ndev_dir = get_user_ndev_dir() / "php"
+    if ndev_dir.exists():
+        for d in ndev_dir.iterdir():
+            if d.is_dir():
+                versions.append(d.name)
+    return sorted(versions)
+
+def manage_service(service: str, action: str):
+    console.print(f"\n[yellow]{action.upper()} -> {service}[/yellow]")
+    if service == "pma":
+        from ndev.linux.runtime.pma import start_pma, stop_pma, restart_pma
+        if action == "start":
+            start_pma()
+        elif action == "stop":
+            stop_pma()
+        elif action == "restart":
+            restart_pma()
+    elif service.startswith("ndev-"):
+        version = service[5:]
+        script_path = sys.argv[0]
+        subprocess.run([sys.executable, script_path, action, version])
+    else:
+        cmd = ["sudo"]
+        if shutil.which("systemctl"):
+            cmd.extend(["systemctl", action, service])
+        else:
+            cmd.extend(["service", service, action])
+        subprocess.run(cmd)
+    console.print("[green]Done[/green]")
+
+def ctl_cmd():
+    """Interactive dashboard to start, stop, or restart local web services."""
+    console.print("[bold blue]==================================================================[/bold blue]")
+    console.print("[bold blue]                 Web Service Management Tool                      [/bold blue]")
+    console.print("[bold blue]==================================================================[/bold blue]\n")
+    
+    # 1. Detect base services status
+    base_services = [("nginx", "Base Service"), ("mariadb", "Base Service"), ("pma", "phpMyAdmin")]
+    php_versions = get_php_versions()
+    
+    table = Table(title="Detected Services")
+    table.add_column("Service", style="cyan")
+    table.add_column("Type", style="magenta")
+    table.add_column("Status", style="bold")
+    
+    for svc, svc_type in base_services:
+        if service_exists(svc):
+            status = service_status(svc)
+            color = "green" if status == "RUNNING" else ("yellow" if status == "NOT INSTALLED" else "red")
+            table.add_row(svc, svc_type, f"[{color}]{status}[/{color}]")
+            
+    for version in php_versions:
+        svc = f"ndev-{version}"
+        status = service_status(svc)
+        color = "green" if status == "RUNNING" else "red"
+        table.add_row(svc, "PHP-FPM", f"[{color}]{status}[/{color}]")
+            
+    console.print(table)
+    console.print("")
+    
+    # 2. Select Action
+    console.print("[bold]Select Action:[/bold]")
+    console.print("  1) Restart (Default)")
+    console.print("  2) Start")
+    console.print("  3) Stop")
+    choice = typer.prompt("Enter choice [1-3]", default=1)
+    
+    action_map = {1: "restart", 2: "start", 3: "stop"}
+    action = action_map.get(choice, "restart")
+    
+    # 3. Select Service
+    console.print("\n[bold]Select Service:[/bold]")
+    console.print("  1) Nginx")
+    console.print("  2) MariaDB")
+    console.print("  3) phpMyAdmin (pma)")
+    console.print("  4) PHP-FPM")
+    console.print("  5) All Services")
+    svc_choice = typer.prompt("Enter choice [1-5]", default=5)
+    
+    php_ver = None
+    if svc_choice in [4, 5]:
+        if php_versions:
+            console.print("\n[bold]Available PHP Versions[/bold]")
+            console.print("----------------------")
+            for i, version in enumerate(php_versions):
+                status = service_status(f"ndev-{version}")
+                console.print(f"  {i + 1}) PHP {version:<12} {status}")
+            console.print(f"  {len(php_versions) + 1}) All PHP-FPM Instances")
+                    
+            console.print("")
+            php_idx = typer.prompt("Select PHP version index", type=int)
+            if php_idx < 1 or php_idx > len(php_versions) + 1:
+                logger.error("Invalid selection.")
+                raise typer.Exit(code=1)
+                
+            if php_idx == len(php_versions) + 1:
+                php_ver = "all"
+            else:
+                php_ver = php_versions[php_idx - 1]
+        
+    services_to_manage = []
+    if svc_choice == 1:
+        services_to_manage = ["nginx"]
+    elif svc_choice == 2:
+        services_to_manage = ["mariadb"]
+    elif svc_choice == 3:
+        services_to_manage = ["pma"]
+    elif svc_choice == 4:
+        if php_ver == "all":
+            services_to_manage = [f"ndev-{v}" for v in php_versions]
+        elif php_ver:
+            services_to_manage = [f"ndev-{php_ver}"]
+    elif svc_choice == 5:
+        services_to_manage = ["nginx", "mariadb", "pma"]
+        if php_ver:
+            if php_ver == "all":
+                services_to_manage.extend([f"ndev-{v}" for v in php_versions])
+            else:
+                services_to_manage.append(f"ndev-{php_ver}")
+                
+    console.print("\n[bold blue]Executing requested actions...[/bold blue]")
+    for svc in services_to_manage:
+        manage_service(svc, action)
+        
+    console.print("\n[bold green]Completed successfully.[/bold green]")
+    console.print("[bold blue]==================================================================[/bold blue]")

ndev/linux/commands/current.py

@@ -0,0 +1,11 @@
+import typer
+from ndev.common.constants import CURRENT_LINK
+from ndev.common.logger import logger
+
+def current_cmd():
+    """Show the currently active PHP version."""
+    if CURRENT_LINK.exists() and CURRENT_LINK.is_symlink():
+        version = CURRENT_LINK.resolve().name
+        logger.info(f"Current active PHP version: {version}")
+    else:
+        logger.info("No active PHP version set. Use 'ndev use <version>' to set one.")