ndev-stack 0.1.0__py3-none-any.whl

ndev/__init__.py

@@ -0,0 +1,8 @@
+"""
+ndev: Fast, cross-platform PHP developer environment for Windows and Linux.
+"""
+__version__ = "0.1.0"
+
+from . import common
+from .common.logger import logger
+from .common import constants

ndev/__main__.py

@@ -0,0 +1,4 @@
+from ndev.cli import main
+
+if __name__ == "__main__":
+    main()

ndev/cli.py

@@ -0,0 +1,24 @@
+"""
+Cross-platform CLI entrypoint for ndev.
+Auto-detects the host operating system (Windows vs. Linux/POSIX)
+and dispatches commands to the appropriate platform runtime engine.
+"""
+from __future__ import annotations
+
+import platform
+import sys
+
+# Ensure UTF-8 output on Windows consoles to prevent glyph corruption
+if sys.platform == "win32":
+    if hasattr(sys.stdout, "reconfigure"):
+        try:
+            sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+            sys.stderr.reconfigure(encoding="utf-8", errors="replace")
+        except Exception:
+            pass
+
+
+from ndev.main import main, app
+
+if __name__ == "__main__":
+    main()

ndev/common/__init__.py

@@ -0,0 +1,3 @@
+"""Common cross-platform utilities, constants, and logging for ndev."""
+from .logger import logger
+from .constants import *

ndev/common/config.py

@@ -0,0 +1,114 @@
+import os
+import tomllib
+from pathlib import Path
+from ndev.common.constants import (
+    NDEV_DIR, CACHE_DIR, DOWNLOADS_DIR, BUILDS_DIR, CHROOT_DIR,
+    LOGS_DIR, RUN_DIR, PHP_DIR, CERTS_DIR, CONFIG_FILE, DEFAULT_CONFIG
+)
+from ndev.common.logger import logger
+
+def init_layout():
+    """Create all required directories in ~/.ndev if they do not exist."""
+    for directory in [NDEV_DIR, CACHE_DIR, DOWNLOADS_DIR, BUILDS_DIR, CHROOT_DIR, LOGS_DIR, RUN_DIR, PHP_DIR, CERTS_DIR]:
+        directory.mkdir(parents=True, exist_ok=True)
+    
+    if not CONFIG_FILE.exists():
+        CONFIG_FILE.write_text(DEFAULT_CONFIG)
+        logger.info(f"Initialized default configuration in {CONFIG_FILE}")
+    else:
+        try:
+            content = CONFIG_FILE.read_text()
+            new_flags = [
+                "--enable-fpm",
+                "--enable-mbstring",
+                "--enable-xml",
+                "--with-openssl",
+                "--with-zlib",
+                "--enable-pdo",
+                "--with-pdo-mysql",
+                "--with-mysqli",
+                "--with-curl",
+                "--enable-bcmath",
+                "--enable-calendar",
+                "--enable-exif",
+                "--enable-ftp",
+                "--enable-intl",
+                "--enable-pcntl",
+                "--enable-sockets",
+                "--enable-opcache",
+                "--enable-soap",
+                "--enable-gd",
+                "--with-jpeg",
+                "--with-webp",
+                "--with-freetype",
+                "--with-zip",
+                "--with-sodium",
+                "--with-bz2",
+                "--with-gmp",
+                "--with-readline"
+            ]
+            missing_flags = [f for f in new_flags if f not in content]
+            if "configure_flags" in content and missing_flags:
+                with open(CONFIG_FILE, "rb") as f:
+                    config = tomllib.load(f)
+                build_sec = config.setdefault("build", {})
+                flags = build_sec.setdefault("configure_flags", [])
+                
+                updated = False
+                for flag in new_flags:
+                    if flag not in flags:
+                        flags.append(flag)
+                        updated = True
+                
+                if updated:
+                    lines = []
+                    for section, s_content in config.items():
+                        lines.append(f"[{section}]")
+                        for k, v in s_content.items():
+                            if isinstance(v, list):
+                                v_str = "[" + ", ".join(f'"{item}"' for item in v) + "]"
+                            elif isinstance(v, str):
+                                v_str = f'"{v}"'
+                            else:
+                                v_str = str(v)
+                            lines.append(f"{k} = {v_str}")
+                        lines.append("")
+                    CONFIG_FILE.write_text("\n".join(lines))
+                    logger.info("Automatically added missing build flags to existing configuration flags.")
+        except Exception as e:
+            logger.warning(f"Failed to migrate configuration file: {e}")
+
+def load_config():
+    """Load configuration from ~/.ndev/config.toml."""
+    init_layout()
+    try:
+        with open(CONFIG_FILE, "rb") as f:
+            return tomllib.load(f)
+    except Exception as e:
+        logger.warning(f"Failed to load configuration: {e}. Using defaults.")
+        return tomllib.loads(DEFAULT_CONFIG)
+
+def update_config(key_path: str, value):
+    """Simple configuration updater. key_path is dot-separated (e.g. 'general.default_version')."""
+    config = load_config()
+    
+    keys = key_path.split(".")
+    d = config
+    for k in keys[:-1]:
+        d = d.setdefault(k, {})
+    d[keys[-1]] = value
+    
+    lines = []
+    for section, content in config.items():
+        lines.append(f"[{section}]")
+        for k, v in content.items():
+            if isinstance(v, list):
+                v_str = "[" + ", ".join(f'"{item}"' for item in v) + "]"
+            elif isinstance(v, str):
+                v_str = f'"{v}"'
+            else:
+                v_str = str(v)
+            lines.append(f"{k} = {v_str}")
+        lines.append("")
+    
+    CONFIG_FILE.write_text("\n".join(lines))

ndev/common/constants.py

@@ -0,0 +1,51 @@
+import os
+from pathlib import Path
+
+NDEV_DIR = Path(os.path.expanduser("~/.ndev")).resolve()
+CACHE_DIR = NDEV_DIR / "cache"
+DOWNLOADS_DIR = NDEV_DIR / "downloads"
+BUILDS_DIR = NDEV_DIR / "builds"
+CHROOT_DIR = NDEV_DIR / "chroot"
+LOGS_DIR = NDEV_DIR / "logs"
+RUN_DIR = NDEV_DIR / "run"
+PHP_DIR = NDEV_DIR / "php"
+CERTS_DIR = NDEV_DIR / "certs"
+CURRENT_LINK = NDEV_DIR / "current"
+CONFIG_FILE = NDEV_DIR / "config.toml"
+
+DEFAULT_CONFIG = """# ndev Configuration
+
+[general]
+default_version = ""
+
+[build]
+configure_flags = [
+    "--enable-fpm",
+    "--enable-mbstring",
+    "--enable-xml",
+    "--with-openssl",
+    "--with-zlib",
+    "--enable-pdo",
+    "--with-pdo-mysql",
+    "--with-mysqli",
+    "--with-curl",
+    "--enable-bcmath",
+    "--enable-calendar",
+    "--enable-exif",
+    "--enable-ftp",
+    "--enable-intl",
+    "--enable-pcntl",
+    "--enable-sockets",
+    "--enable-opcache",
+    "--enable-soap",
+    "--enable-gd",
+    "--with-jpeg",
+    "--with-webp",
+    "--with-freetype",
+    "--with-zip",
+    "--with-sodium",
+    "--with-bz2",
+    "--with-gmp",
+    "--with-readline"
+]
+"""

ndev/common/github.py

@@ -0,0 +1,13 @@
+import httpx
+from ndev.common.logger import logger
+
+def fetch_releases(major_version: int) -> dict:
+    """Fetch PHP releases metadata for a major version from php.net."""
+    url = f"https://www.php.net/releases/index.php?json=1&version={major_version}&max=100"
+    try:
+        response = httpx.get(url, timeout=10.0)
+        response.raise_for_status()
+        return response.json()
+    except Exception as e:
+        logger.warning(f"Failed to fetch PHP releases for major version {major_version}: {e}")
+        return {}

ndev/common/logger.py

@@ -0,0 +1,11 @@
+import logging
+from rich.logging import RichHandler
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(message)s",
+    datefmt="[%X]",
+    handlers=[RichHandler(rich_tracebacks=True, show_path=False, markup=True)]
+)
+
+logger = logging.getLogger("ndev")

ndev/common/manifest.py

@@ -0,0 +1,41 @@
+import json
+import datetime
+from pathlib import Path
+from ndev.common.constants import NDEV_DIR
+from ndev.common.logger import logger
+
+MANIFEST_FILE = NDEV_DIR / "manifest.json"
+
+def load_manifest() -> dict:
+    """Load the manifest of installed versions."""
+    if not MANIFEST_FILE.exists():
+        return {"installed": {}}
+    try:
+        return json.loads(MANIFEST_FILE.read_text())
+    except Exception as e:
+        logger.warning(f"Failed to read manifest: {e}. Returning empty.")
+        return {"installed": {}}
+
+def save_manifest(manifest: dict):
+    """Save the manifest of installed versions."""
+    try:
+        MANIFEST_FILE.write_text(json.dumps(manifest, indent=2))
+    except Exception as e:
+        logger.error(f"Failed to write manifest: {e}")
+
+def add_installed_version(version: str, path: str, configure_flags: list[str]):
+    """Add a version to the installed manifest."""
+    manifest = load_manifest()
+    manifest["installed"][version] = {
+        "path": path,
+        "installed_at": datetime.datetime.now().isoformat(),
+        "configure_flags": configure_flags
+    }
+    save_manifest(manifest)
+
+def remove_installed_version(version: str):
+    """Remove a version from the installed manifest."""
+    manifest = load_manifest()
+    if version in manifest["installed"]:
+        del manifest["installed"][version]
+        save_manifest(manifest)

ndev/common/utils.py

@@ -0,0 +1,96 @@
+import subprocess
+import shlex
+import sys
+from rich.console import Console
+from ndev.common.logger import logger
+
+console = Console()
+
+def run_command(cmd, cwd=None, env=None, check=True, capture_output=False, show_logs=True):
+    """Run a shell command, printing output in real-time or capturing it."""
+    if isinstance(cmd, str):
+        cmd_args = shlex.split(cmd)
+    else:
+        cmd_args = cmd
+        
+    logger.debug(f"Running command: {' '.join(shlex.quote(arg) for arg in cmd_args)} in cwd={cwd}")
+    
+    if capture_output:
+        res = subprocess.run(cmd_args, cwd=cwd, env=env, capture_output=True, text=True)
+        if check and res.returncode != 0:
+            logger.error(f"Command failed with exit code {res.returncode}")
+            logger.error(f"Stdout: {res.stdout}")
+            logger.error(f"Stderr: {res.stderr}")
+            raise subprocess.CalledProcessError(res.returncode, cmd_args, res.stdout, res.stderr)
+        return res
+        
+    p = subprocess.Popen(
+        cmd_args,
+        cwd=cwd,
+        env=env,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+        bufsize=1
+    )
+    
+    output_lines = []
+    if p.stdout:
+        for line in p.stdout:
+            if show_logs:
+                sys.stdout.write(line)
+                sys.stdout.flush()
+            output_lines.append(line)
+            
+    p.wait()
+    if check and p.returncode != 0:
+        output_str = "".join(output_lines)
+        if not show_logs:
+            logger.error(f"Command failed with exit code {p.returncode}")
+            logger.error("Command output:\n" + output_str)
+        raise subprocess.CalledProcessError(p.returncode, cmd_args, output_str)
+    return p.returncode
+
+def get_version_or_prompt(version: str = None, prompt_message: str = "PHP version") -> str:
+    """Return the provided version, the active version if set, or prompt the user."""
+    import typer
+    from ndev.common.constants import CURRENT_LINK, PHP_DIR
+    
+    if version:
+        return version
+        
+    if CURRENT_LINK.exists() and CURRENT_LINK.is_symlink():
+        return CURRENT_LINK.resolve().name
+        
+    installed_versions = []
+    if PHP_DIR.exists():
+        for path in PHP_DIR.iterdir():
+            if path.is_dir():
+                installed_versions.append(path.name)
+                
+    if installed_versions:
+        from packaging.version import parse as parse_version
+        try:
+            installed_versions = sorted(installed_versions, key=parse_version)
+        except Exception:
+            installed_versions = sorted(installed_versions)
+            
+        console.print("\n[bold]Installed PHP Versions[/bold]")
+        console.print("----------------------")
+        for i, v in enumerate(installed_versions):
+            console.print(f" {i + 1}) {v}")
+        console.print("")
+        
+        try:
+            choice = typer.prompt("Select PHP version index or enter version directly", default="1")
+            try:
+                idx = int(choice)
+                if 1 <= idx <= len(installed_versions):
+                    return installed_versions[idx - 1]
+            except ValueError:
+                return choice.strip()
+        except Exception:
+            pass
+            
+    return typer.prompt(prompt_message).strip()
+

ndev/linux/__init__.py

@@ -0,0 +1 @@
+"""Linux runtime engine and CLI for ndev."""

ndev/linux/chroot/manager.py

@@ -0,0 +1,63 @@
+import os
+import subprocess
+from pathlib import Path
+from ndev.common.constants import CHROOT_DIR, NDEV_DIR
+from ndev.common.logger import logger
+from ndev.common.utils import run_command
+
+class SandboxManager:
+    def __init__(self):
+        self.chroot_dir = CHROOT_DIR
+        self.ndev_dir = NDEV_DIR
+
+    def init_sandbox(self):
+        """Prepare local directories in ~/.ndev/chroot for mounting."""
+        for sub_dir in ["bin", "sbin", "lib", "lib64", "usr", "etc", "proc", "dev", "sys", "tmp", "builds", "home"]:
+            (self.chroot_dir / sub_dir).mkdir(parents=True, exist_ok=True)
+        # Ensure usr/local exists
+        (self.chroot_dir / "usr" / "local").mkdir(parents=True, exist_ok=True)
+
+    def get_bwrap_command(self, cmd_args, cwd=None):
+        """Build bubblewrap command that mounts the host system read-only."""
+        self.init_sandbox()
+        
+        bwrap_cmd = [
+            "bwrap",
+            "--bind", str(self.chroot_dir), "/",
+            "--ro-bind-try", "/usr", "/usr",
+            "--bind", str(self.chroot_dir / "usr" / "local"), "/usr/local",
+            "--ro-bind-try", "/lib", "/lib",
+            "--ro-bind-try", "/lib64", "/lib64",
+            "--ro-bind-try", "/bin", "/bin",
+            "--ro-bind-try", "/sbin", "/sbin",
+            "--ro-bind-try", "/etc", "/etc",
+            "--proc", "/proc",
+            "--dev", "/dev",
+            "--tmpfs", "/tmp",
+            "--bind", str(self.ndev_dir), str(self.ndev_dir),
+        ]
+        
+        home_dir = os.path.expanduser("~")
+        bwrap_cmd.extend(["--bind", home_dir, home_dir])
+        
+        if cwd:
+            bwrap_cmd.extend(["--chdir", str(cwd)])
+            
+        bwrap_cmd.append("--")
+        bwrap_cmd.extend(cmd_args)
+        
+        return bwrap_cmd
+
+    def run(self, cmd_args, cwd=None, env=None, check=True, show_logs=True):
+        """Run command inside the bubblewrap sandbox."""
+        if env is None:
+            env = os.environ.copy()
+            
+        env["PKG_CONFIG_PATH"] = "/usr/local/lib/pkgconfig:/usr/local/lib/x86_64-linux-gnu/pkgconfig:" + env.get("PKG_CONFIG_PATH", "")
+        env["LD_LIBRARY_PATH"] = "/usr/local/lib:/usr/local/lib/x86_64-linux-gnu:" + env.get("LD_LIBRARY_PATH", "")
+        env["LIBRARY_PATH"] = "/usr/local/lib:/usr/local/lib/x86_64-linux-gnu:" + env.get("LIBRARY_PATH", "")
+        env["CPATH"] = "/usr/local/include:" + env.get("CPATH", "")
+        env["PATH"] = "/usr/local/bin:" + env.get("PATH", "")
+        
+        bwrap_cmd = self.get_bwrap_command(cmd_args, cwd=cwd)
+        return run_command(bwrap_cmd, env=env, check=check, show_logs=show_logs)

ndev/linux/chroot/packages.py

@@ -0,0 +1,91 @@
+import shutil
+import os
+from pathlib import Path
+from ndev.linux.chroot.manager import SandboxManager
+from ndev.common.logger import logger
+from ndev.common.utils import run_command
+
+def install_host_packages(packages: list[str], show_logs: bool = False):
+    """Downloads, extracts, and moves package files to usr/local inside chroot."""
+    if not packages:
+        return
+        
+    logger.info(f"Installing packages into sandbox: {', '.join(packages)}")
+    sandbox = SandboxManager()
+    sandbox.init_sandbox()
+    
+    local_dir = sandbox.chroot_dir / "usr" / "local"
+    local_dir.mkdir(parents=True, exist_ok=True)
+    for sub in ["bin", "lib", "include", "share"]:
+        (local_dir / sub).mkdir(parents=True, exist_ok=True)
+        
+    tmp_dir = sandbox.chroot_dir / "tmp" / "pkg_downloads"
+    tmp_dir.mkdir(parents=True, exist_ok=True)
+    
+    try:
+        cmd = ["apt-get", "download"] + packages
+        run_command(cmd, cwd=tmp_dir, show_logs=show_logs)
+        
+        for deb in tmp_dir.glob("*.deb"):
+            extract_dest = tmp_dir / deb.stem
+            extract_dest.mkdir(parents=True, exist_ok=True)
+            run_command(["dpkg", "-x", str(deb), str(extract_dest)], show_logs=show_logs)
+            
+            usr_src = extract_dest / "usr"
+            if usr_src.exists():
+                for root, dirs, files in os.walk(usr_src):
+                    rel_root = Path(root).relative_to(usr_src)
+                    dest_root = local_dir / rel_root
+                    dest_root.mkdir(parents=True, exist_ok=True)
+                    
+                    # Move directory symlinks
+                    for d in list(dirs):
+                        src_dir = Path(root) / d
+                        if src_dir.is_symlink():
+                            dest_dir = dest_root / d
+                            if dest_dir.exists() or dest_dir.is_symlink():
+                                if dest_dir.is_dir() and not dest_dir.is_symlink():
+                                    shutil.rmtree(dest_dir)
+                                else:
+                                    dest_dir.unlink()
+                            shutil.move(src_dir, dest_dir)
+                            dirs.remove(d)
+
+                    for file in files:
+                        src_file = Path(root) / file
+                        dest_file = dest_root / file
+                        if dest_file.exists():
+                            dest_file.unlink()
+                        shutil.move(src_file, dest_file)
+                        
+        # Fix broken relative symlinks in usr/local/lib pointing to multiarch runtime libraries
+        lib_dir = local_dir / "lib"
+        if lib_dir.exists():
+            for root, dirs, files in os.walk(lib_dir):
+                for file in files:
+                    file_path = Path(root) / file
+                    if file_path.is_symlink():
+                        target = os.readlink(file_path)
+                        # Check if it is a broken link
+                        if not file_path.exists():
+                            # Find it on the host system
+                            host_paths = [
+                                Path("/usr/lib/x86_64-linux-gnu"),
+                                Path("/lib/x86_64-linux-gnu"),
+                                Path("/usr/lib"),
+                                Path("/lib")
+                            ]
+                            resolved = False
+                            for hp in host_paths:
+                                host_target = hp / target
+                                if host_target.exists():
+                                    logger.info(f"Fixing broken symlink {file_path.name} -> {host_target}")
+                                    file_path.unlink()
+                                    file_path.symlink_to(host_target)
+                                    resolved = True
+                                    break
+                            if not resolved:
+                                logger.warning(f"Could not resolve symlink target '{target}' for {file_path}")
+                        
+    finally:
+        shutil.rmtree(tmp_dir, ignore_errors=True)

ndev/linux/chroot/shell.py

@@ -0,0 +1,9 @@
+import os
+from ndev.linux.chroot.manager import SandboxManager
+
+def enter_sandbox_shell():
+    """Launch interactive bash shell inside the bubblewrap sandbox."""
+    sandbox = SandboxManager()
+    cmd = ["bash"]
+    bwrap_cmd = sandbox.get_bwrap_command(cmd)
+    os.execvp(bwrap_cmd[0], bwrap_cmd)