ndev-stack 0.1.0__py3-none-any.whl

ndev/win/core/db.py

@@ -0,0 +1,265 @@
+"""
+MariaDB database/user management, shelling out to mysql.exe and mysqldump.exe.
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+from . import paths
+
+DEFAULT_ROOT_PASSWORD = "root"
+DEFAULT_HOST = "127.0.0.1"
+DEFAULT_PORT = 3306
+
+
+def _mysql_exe() -> str:
+    exe = paths.MARIADB_DIR / "bin" / "mysql.exe"
+    if exe.exists():
+        return str(exe)
+    system_exe = shutil.which("mysql") or shutil.which("mysql.exe")
+    if system_exe:
+        return system_exe
+    raise FileNotFoundError("MariaDB/MySQL client isn't installed -- run `ndev setup` first")
+
+
+def _mysqldump_exe() -> str:
+    exe = paths.MARIADB_DIR / "bin" / "mysqldump.exe"
+    if exe.exists():
+        return str(exe)
+    system_exe = shutil.which("mysqldump") or shutil.which("mysqldump.exe")
+    if system_exe:
+        return system_exe
+    raise FileNotFoundError("mysqldump isn't installed -- run `ndev setup` first")
+
+
+def run_sql(
+    sql: str,
+    root_password: str = DEFAULT_ROOT_PASSWORD,
+    host: str = DEFAULT_HOST,
+    port: int = DEFAULT_PORT,
+    user: str = "root",
+) -> str:
+    cmd = [
+        _mysql_exe(),
+        "-h", host,
+        "-P", str(port),
+        "-u", user,
+        "--connect-timeout=5",
+        f"--password={root_password}" if root_password else "",
+        "--batch",
+        "--skip-column-names",
+        "-e", sql,
+    ]
+    cmd = [arg for arg in cmd if arg]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        err = result.stderr.strip()
+        if "Access denied for user" in err:
+            raise RuntimeError(f"Authentication failed: Access denied for '{user}'. Please verify your database password.")
+        raise RuntimeError(f"MySQL error: {err}")
+    return result.stdout
+
+
+def test_connection(
+    root_password: str = DEFAULT_ROOT_PASSWORD,
+    host: str = DEFAULT_HOST,
+    port: int = DEFAULT_PORT,
+    user: str = "root",
+) -> tuple[bool, str]:
+    """Test connection to MariaDB and return (success, error_message)."""
+    try:
+        run_sql("SELECT 1;", root_password=root_password, host=host, port=port, user=user)
+        return True, ""
+    except Exception as e:
+        return False, str(e)
+
+
+def _escape_sql_ident(ident: str) -> str:
+    """Safely escape a SQL identifier using backticks."""
+    clean = ident.replace("`", "``")
+    return f"`{clean}`"
+
+
+def _escape_sql_string(val: str) -> str:
+    """Safely escape a SQL string literal."""
+    return val.replace("\\", "\\\\").replace("'", "''")
+
+
+def create_db(
+    name: str,
+    owner: str = "",
+    user_host: str = "%",
+    charset: str = "utf8mb4",
+    collation: str = "utf8mb4_unicode_ci",
+    root_password: str = DEFAULT_ROOT_PASSWORD,
+    host: str = DEFAULT_HOST,
+    port: int = DEFAULT_PORT,
+) -> None:
+    db_ident = _escape_sql_ident(name)
+    sql = f"CREATE DATABASE IF NOT EXISTS {db_ident} CHARACTER SET {charset} COLLATE {collation};"
+    if owner:
+        owner_str = _escape_sql_string(owner)
+        host_str = _escape_sql_string(user_host)
+        sql += f" GRANT ALL PRIVILEGES ON {db_ident}.* TO '{owner_str}'@'{host_str}'; FLUSH PRIVILEGES;"
+    run_sql(sql, root_password=root_password, host=host, port=port)
+
+
+def drop_db(
+    name: str,
+    root_password: str = DEFAULT_ROOT_PASSWORD,
+    host: str = DEFAULT_HOST,
+    port: int = DEFAULT_PORT,
+) -> None:
+    db_ident = _escape_sql_ident(name)
+    run_sql(f"DROP DATABASE IF EXISTS {db_ident};", root_password=root_password, host=host, port=port)
+
+
+def export_db(
+    name: str,
+    output_path: Optional[str | Path] = None,
+    root_password: str = DEFAULT_ROOT_PASSWORD,
+    host: str = DEFAULT_HOST,
+    port: int = DEFAULT_PORT,
+    user: str = "root",
+    quick: bool = True,
+    single_transaction: bool = True,
+    routines: bool = True,
+    triggers: bool = True,
+) -> str:
+    cmd = [
+        _mysqldump_exe(),
+        "-h", host,
+        "-P", str(port),
+        "-u", user,
+    ]
+    if root_password:
+        cmd.append(f"--password={root_password}")
+    if quick:
+        cmd.append("--quick")
+    if single_transaction:
+        cmd.append("--single-transaction")
+    if routines:
+        cmd.append("--routines")
+    if triggers:
+        cmd.append("--triggers")
+    cmd.append(name)
+
+    if output_path:
+        out = Path(output_path).resolve()
+        out.parent.mkdir(parents=True, exist_ok=True)
+        with open(out, "w", encoding="utf-8") as f:
+            res = subprocess.run(cmd, stdout=f, stderr=subprocess.PIPE, text=True)
+        if res.returncode != 0:
+            raise RuntimeError(f"mysqldump error: {res.stderr.strip()}")
+        return str(out)
+    else:
+        res = subprocess.run(cmd, capture_output=True, text=True)
+        if res.returncode != 0:
+            raise RuntimeError(f"mysqldump error: {res.stderr.strip()}")
+        return res.stdout
+
+
+def list_databases(
+    root_password: str = DEFAULT_ROOT_PASSWORD,
+    host: str = DEFAULT_HOST,
+    port: int = DEFAULT_PORT,
+) -> list[str]:
+    out = run_sql("SHOW DATABASES;", root_password=root_password, host=host, port=port)
+    lines = [line.strip() for line in out.strip().splitlines() if line.strip()]
+    system_dbs = {"information_schema", "mysql", "performance_schema", "sys"}
+    return [db for db in lines if db.lower() not in system_dbs]
+
+
+def create_user(
+    username: str,
+    password: str,
+    grant_db: Optional[str] = None,
+    user_host: str = "localhost",
+    root_password: str = DEFAULT_ROOT_PASSWORD,
+    host: str = DEFAULT_HOST,
+    port: int = DEFAULT_PORT,
+) -> None:
+    u_str = _escape_sql_string(username)
+    p_str = _escape_sql_string(password)
+    h_str = _escape_sql_string(user_host)
+    
+    hosts_to_create = [h_str]
+    if user_host in ("localhost", "127.0.0.1"):
+        hosts_to_create = ["localhost", "127.0.0.1", "%"]
+
+    sql_parts = []
+    for h in hosts_to_create:
+        sql_parts.append(f"CREATE USER IF NOT EXISTS '{u_str}'@'{h}' IDENTIFIED BY '{p_str}';")
+        if grant_db:
+            db_ident = _escape_sql_ident(grant_db)
+            sql_parts.append(f"GRANT ALL PRIVILEGES ON {db_ident}.* TO '{u_str}'@'{h}';")
+    sql_parts.append("FLUSH PRIVILEGES;")
+    run_sql(" ".join(sql_parts), root_password=root_password, host=host, port=port)
+
+
+def drop_user(
+    username: str,
+    user_host: str = "localhost",
+    root_password: str = DEFAULT_ROOT_PASSWORD,
+    host: str = DEFAULT_HOST,
+    port: int = DEFAULT_PORT,
+) -> None:
+    u_str = _escape_sql_string(username)
+    h_str = _escape_sql_string(user_host)
+    hosts_to_drop = [h_str]
+    if user_host in ("localhost", "127.0.0.1"):
+        hosts_to_drop = ["localhost", "127.0.0.1", "%"]
+
+    sql_parts = []
+    for h in hosts_to_drop:
+        sql_parts.append(f"DROP USER IF EXISTS '{u_str}'@'{h}';")
+    sql_parts.append("FLUSH PRIVILEGES;")
+    run_sql(" ".join(sql_parts), root_password=root_password, host=host, port=port)
+
+
+def list_users(
+    root_password: str = DEFAULT_ROOT_PASSWORD,
+    host: str = DEFAULT_HOST,
+    port: int = DEFAULT_PORT,
+) -> list[str]:
+    out = run_sql("SELECT CONCAT(User, '@', Host) FROM mysql.user;", root_password=root_password, host=host, port=port)
+    lines = [line.strip() for line in out.strip().splitlines() if line.strip()]
+    system_users = {"root@localhost", "root@127.0.0.1", "root@::1", "mariadb.sys@localhost", "mysql@localhost"}
+    return [u for u in lines if u.lower() not in system_users]
+
+
+def import_db(
+    name: str,
+    sql_file_path: str | Path,
+    root_password: str = DEFAULT_ROOT_PASSWORD,
+    host: str = DEFAULT_HOST,
+    port: int = DEFAULT_PORT,
+    user: str = "root",
+) -> None:
+    """Import a SQL dump file into a database."""
+    file_path = Path(sql_file_path).resolve()
+    if not file_path.exists():
+        raise FileNotFoundError(f"SQL file does not exist: {file_path}")
+
+    # Ensure database exists before import
+    create_db(name, root_password=root_password, host=host, port=port)
+
+    cmd = [
+        _mysql_exe(),
+        "-h", host,
+        "-P", str(port),
+        "-u", user,
+        "--connect-timeout=5",
+    ]
+    if root_password:
+        cmd.append(f"--password={root_password}")
+    cmd.append(name)
+
+    with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+        res = subprocess.run(cmd, stdin=f, capture_output=True, text=True)
+    if res.returncode != 0:
+        raise RuntimeError(f"MySQL import error: {res.stderr.strip()}")

ndev/win/core/elevate.py

@@ -0,0 +1,94 @@
+"""
+UAC elevation helpers for Windows.
+
+ndev (Linux) shells out to `sudo` for vhost/setup/hosts-file work.
+Windows has no equivalent shell primitive: elevation is a distinct
+process launch via ShellExecuteW's "runas" verb, which triggers the
+UAC prompt. There is no way to elevate an already-running process,
+so commands that need admin rights either:
+
+  1. Check is_admin() and relaunch themselves elevated, or
+  2. Shell out to a small elevated helper for just the privileged
+     step (e.g. writing to the hosts file), keeping the rest of the
+     command running unprivileged.
+
+Option 2 is used for hosts / vhost so the bulk of ndev
+never needs to run elevated.
+"""
+from __future__ import annotations
+
+import ctypes
+import subprocess
+import sys
+from pathlib import Path
+
+
+def is_admin() -> bool:
+    try:
+        return ctypes.windll.shell32.IsUserAnAdmin() != 0
+    except Exception:
+        return False
+
+
+def relaunch_as_admin(argv: list[str] | None = None) -> None:
+    """Re-invoke the current script elevated, then exit the caller."""
+    argv = argv or sys.argv
+    params = " ".join(f'"{a}"' for a in argv[1:])
+    ctypes.windll.shell32.ShellExecuteW(
+        None, "runas", sys.executable, f'"{argv[0]}" {params}', None, 1
+    )
+    sys.exit(0)
+
+
+def run_elevated(command: list[str], wait: bool = True) -> int:
+    """
+    Run a single command elevated. If already running as Administrator,
+    executes directly without triggering a UAC prompt.
+    Otherwise uses ShellExecuteExW with the 'runas' verb.
+    """
+    if is_admin():
+        res = subprocess.run(command)
+        return res.returncode
+
+    exe, *args = command
+    params = " ".join(f'"{a}"' for a in args)
+    SEE_MASK_NOCLOSEPROCESS = 0x00000040
+
+    class SHELLEXECUTEINFO(ctypes.Structure):
+        _fields_ = [
+            ("cbSize", ctypes.c_ulong),
+            ("fMask", ctypes.c_ulong),
+            ("hwnd", ctypes.c_void_p),
+            ("lpVerb", ctypes.c_wchar_p),
+            ("lpFile", ctypes.c_wchar_p),
+            ("lpParameters", ctypes.c_wchar_p),
+            ("lpDirectory", ctypes.c_wchar_p),
+            ("nShow", ctypes.c_int),
+            ("hInstApp", ctypes.c_void_p),
+            ("lpIDList", ctypes.c_void_p),
+            ("lpClass", ctypes.c_wchar_p),
+            ("hkeyClass", ctypes.c_void_p),
+            ("dwHotKey", ctypes.c_ulong),
+            ("hIconOrMonitor", ctypes.c_void_p),
+            ("hProcess", ctypes.c_void_p),
+        ]
+
+    sei = SHELLEXECUTEINFO()
+    sei.cbSize = ctypes.sizeof(sei)
+    sei.fMask = SEE_MASK_NOCLOSEPROCESS
+    sei.lpVerb = "runas"
+    sei.lpFile = exe
+    sei.lpParameters = params
+    sei.nShow = 0
+
+    if not ctypes.windll.shell32.ShellExecuteExW(ctypes.byref(sei)):
+        raise OSError("Elevation request was rejected or cancelled (UAC).")
+
+    if wait and sei.hProcess:
+        WAIT_INFINITE = 0xFFFFFFFF
+        ctypes.windll.kernel32.WaitForSingleObject(sei.hProcess, WAIT_INFINITE)
+        exit_code = ctypes.c_ulong(0)
+        ctypes.windll.kernel32.GetExitCodeProcess(sei.hProcess, ctypes.byref(exit_code))
+        ctypes.windll.kernel32.CloseHandle(sei.hProcess)
+        return exit_code.value
+    return 0

ndev/win/core/ext.py

@@ -0,0 +1,241 @@
+"""
+PECL extension manager for Windows (precompiled DLL downloads from downloads.php.net).
+"""
+from __future__ import annotations
+
+import re
+import shutil
+import urllib.error
+import urllib.request
+import zipfile
+from pathlib import Path
+from typing import Optional
+
+from . import paths, php
+
+PECL_RELEASES_BASE = "https://downloads.php.net/~windows/pecl/releases"
+KNOWN_TOOLSETS = ["vs17", "vs16", "vc15", "vc14", "vc11"]
+
+
+def _http_get_text(url: str) -> str:
+    req = urllib.request.Request(url, headers={"User-Agent": "ndev/0.1.0"})
+    with urllib.request.urlopen(req, timeout=30) as resp:
+        return resp.read().decode("utf-8", errors="ignore")
+
+
+def list_ext_versions(ext: str) -> list[str]:
+    """Directory listing of available versions for a PECL extension."""
+    try:
+        html = _http_get_text(f"{PECL_RELEASES_BASE}/{ext}/")
+    except Exception as e:
+        raise RuntimeError(f"Could not fetch PECL listing for '{ext}': {e}")
+    raw_versions = set(re.findall(r'href="([\d][\w.\-]*)/"', html))
+    return sorted(raw_versions, key=php._version_key)
+
+
+def _is_thread_safe(php_version: str) -> bool:
+    target_ver = php_version
+    try:
+        target_ver = php.resolve_installed(php_version)
+    except Exception:
+        pass
+    import subprocess
+    exe = php.php_exe(target_ver)
+    if exe.exists():
+        try:
+            out = subprocess.run([str(exe), "-i"], capture_output=True, text=True, timeout=10).stdout
+            if "Thread Safety => disabled" in out:
+                return False
+            if "Thread Safety => enabled" in out:
+                return True
+        except Exception:
+            pass
+    # ndev-win installs Thread Safe (TS) builds by default
+    return True
+
+
+def find_release_zip(
+    ext: str,
+    ext_version: Optional[str],
+    php_version: str,
+    arch: str = "x64",
+    thread_safe: Optional[bool] = None,
+) -> str:
+    major_minor = ".".join(php_version.split(".")[:2])
+    is_ts = thread_safe if thread_safe is not None else _is_thread_safe(php_version)
+    ts_tag = "ts" if is_ts else "nts"
+
+    # If no extension version specified, search versions in descending order
+    versions = [ext_version] if ext_version else list_ext_versions(ext)[::-1]
+    if not versions:
+        raise FileNotFoundError(f"No versions found on PECL for extension '{ext}'")
+
+    for v in versions:
+        if not v:
+            continue
+        dir_url = f"{PECL_RELEASES_BASE}/{ext}/{v}/"
+        try:
+            html = _http_get_text(dir_url)
+        except Exception:
+            continue
+        available = set(re.findall(r'href="(php_[\w.\-]+\.zip)"', html))
+
+        for toolset in KNOWN_TOOLSETS:
+            name = f"php_{ext}-{v}-{major_minor}-{ts_tag}-{toolset}-{arch}.zip"
+            if name in available:
+                return dir_url + name
+            # Also try case-insensitive or without arch if matching
+            for avail_name in available:
+                if avail_name.lower() == name.lower():
+                    return dir_url + avail_name
+
+    raise FileNotFoundError(
+        f"No precompiled {ext} build found for PHP {major_minor} ({ts_tag}, {arch}). "
+        f"Checked versions: {versions[:5]}"
+    )
+
+
+def install(
+    ext: str,
+    ext_version: Optional[str],
+    php_version: str,
+    arch: str = "x64",
+    thread_safe: Optional[bool] = None,
+) -> Path:
+    zip_url = find_release_zip(ext, ext_version, php_version, arch, thread_safe)
+    zip_path = paths.DOWNLOADS_DIR / Path(zip_url).name
+    if not zip_path.exists() or zip_path.stat().st_size == 0:
+        req = urllib.request.Request(zip_url, headers={"User-Agent": "ndev/0.1.0"})
+        tmp = zip_path.with_suffix(".part")
+        try:
+            with urllib.request.urlopen(req, timeout=90) as resp, open(tmp, "wb") as f:
+                chunk_size = 65536
+                while True:
+                    chunk = resp.read(chunk_size)
+                    if not chunk:
+                        break
+                    f.write(chunk)
+            if tmp.exists() and tmp.stat().st_size > 0:
+                if zip_path.exists():
+                    zip_path.unlink()
+                tmp.rename(zip_path)
+            else:
+                raise RuntimeError(f"Download from {zip_url} resulted in empty file.")
+        except Exception:
+            if tmp.exists():
+                tmp.unlink(missing_ok=True)
+            raise
+
+    ext_dir = paths.version_dir(php_version) / "ext"
+    ext_dir.mkdir(parents=True, exist_ok=True)
+
+    v_dir = paths.version_dir(php_version)
+    with zipfile.ZipFile(zip_path) as zf:
+        dll_names = [n for n in zf.namelist() if n.lower().endswith(".dll")]
+        if not dll_names:
+            raise RuntimeError(f"No .dll found inside {zip_path.name}")
+        for name in dll_names:
+            data = zf.read(name)
+            filename = Path(name).name
+            if filename.lower().startswith("php_"):
+                (ext_dir / filename).write_bytes(data)
+            else:
+                # Place runtime dependency DLLs (e.g. libssh2.dll) in PHP root for Windows DLL loader
+                (v_dir / filename).write_bytes(data)
+
+    enable(ext, php_version)
+    return ext_dir
+
+
+def _ini_path(php_version: str) -> Path:
+    target_ver = php_version
+    try:
+        target_ver = php.resolve_installed(php_version)
+    except Exception:
+        pass
+    return paths.version_dir(target_ver) / "php.ini"
+
+
+ZEND_EXTENSIONS = {"xdebug", "opcache"}
+
+
+def enable(ext: str, php_version: str) -> None:
+    ini = _ini_path(php_version)
+    if not ini.exists():
+        return
+    text = ini.read_text(encoding="utf-8", errors="ignore")
+    directive = "zend_extension" if ext.lower() in ZEND_EXTENSIONS else "extension"
+    
+    # Check if already enabled
+    pattern_active = rf"^\s*(?:extension|zend_extension)\s*=\s*(?:php_)?{re.escape(ext)}(?:\.dll)?\s*$"
+    if re.search(pattern_active, text, flags=re.MULTILINE):
+        return
+
+    # Check if disabled with semicolon
+    pattern_disabled = rf"^\s*;\s*(?:extension|zend_extension)\s*=\s*(?:php_)?{re.escape(ext)}(?:\.dll)?\s*$"
+    if re.search(pattern_disabled, text, flags=re.MULTILINE):
+        text = re.sub(pattern_disabled, f"{directive}={ext}", text, flags=re.MULTILINE)
+    else:
+        text += f"\n{directive}={ext}\n"
+
+    ini.write_text(text, encoding="utf-8")
+
+
+def disable(ext: str, php_version: str) -> None:
+    ini = _ini_path(php_version)
+    if not ini.exists():
+        return
+    text = ini.read_text(encoding="utf-8", errors="ignore")
+    pattern_active = rf"^\s*((?:extension|zend_extension)\s*=\s*(?:php_)?{re.escape(ext)}(?:\.dll)?)\s*$"
+    if re.search(pattern_active, text, flags=re.MULTILINE):
+        text = re.sub(pattern_active, r";\1", text, flags=re.MULTILINE)
+        ini.write_text(text, encoding="utf-8")
+
+
+def uninstall(ext: str, php_version: str) -> None:
+    target_ver = php_version
+    try:
+        target_ver = php.resolve_installed(php_version)
+    except Exception:
+        pass
+    disable(ext, target_ver)
+    ext_dir = paths.version_dir(target_ver) / "ext"
+    if ext_dir.exists():
+        for dll in ext_dir.glob(f"*{ext}*.dll"):
+            try:
+                dll.unlink()
+            except Exception:
+                pass
+
+
+def list_status(php_version: str) -> dict[str, bool]:
+    """Returns {ext_name: enabled} for all detected extensions in php.ini and ext/ folder."""
+    target_ver = php_version
+    try:
+        target_ver = php.resolve_installed(php_version)
+    except Exception:
+        pass
+
+    status: dict[str, bool] = {}
+    ext_dir = paths.version_dir(target_ver) / "ext"
+    if ext_dir.exists():
+        for dll in ext_dir.glob("*.dll"):
+            name = dll.stem
+            if name.startswith("php_"):
+                name = name[4:]
+            status[name] = False
+
+    ini = _ini_path(target_ver)
+    if ini.exists():
+        for line in ini.read_text(encoding="utf-8", errors="ignore").splitlines():
+            line = line.strip()
+            m = re.match(r"^(;)?\s*(?:extension|zend_extension)\s*=\s*(?:php_)?(\S+?)(?:\.dll)?\s*$", line)
+            if m:
+                name = m.group(2)
+                # Filter out comment placeholders or paths in default template php.ini
+                if "/" in name or "\\" in name or name in ("modulename", "php_modulename", "dl_test"):
+                    continue
+                is_enabled = m.group(1) is None
+                status[name] = is_enabled
+
+    return dict(sorted(status.items()))