ndev-stack 0.1.0__py3-none-any.whl

ndev/win/core/fcgi.py

@@ -0,0 +1,216 @@
+"""
+FastCGI worker pool management for Windows.
+
+Windows has no php-fpm SAPI (it's POSIX-only: relies on fork()).
+The native substitute is a pool of `php-cgi.exe` processes, each
+bound to its own TCP port, load-balanced by an Nginx `upstream` block.
+
+State (pid + ports per version) is persisted as JSON under
+~/.ndev/run/<version>.json so `stop`/`status` work across CLI invocations.
+Process liveness is verified on every query.
+"""
+from __future__ import annotations
+
+import ctypes
+import json
+import subprocess
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+import os
+
+from . import paths
+
+CREATE_NEW_PROCESS_GROUP = 0x00000200
+CREATE_NO_WINDOW = 0x08000000
+PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
+PROCESS_TERMINATE = 0x0001
+STILL_ACTIVE = 259
+
+
+@dataclass
+class WorkerState:
+    pid: int
+    port: int
+
+
+def is_pid_alive(pid: int, expected_name: str | None = None) -> bool:
+    """Check if a process with given PID is actively running on Windows, matching exe name if specified."""
+    if pid <= 0:
+        return False
+    handle = ctypes.windll.kernel32.OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, False, pid)
+    if not handle:
+        return False
+    try:
+        exit_code = ctypes.c_ulong(0)
+        success = ctypes.windll.kernel32.GetExitCodeProcess(handle, ctypes.byref(exit_code))
+        if not success or exit_code.value != STILL_ACTIVE:
+            return False
+        if expected_name:
+            buf = (ctypes.c_wchar * 1024)()
+            size = ctypes.c_ulong(1024)
+            if ctypes.windll.kernel32.QueryFullProcessImageNameW(handle, 0, buf, ctypes.byref(size)):
+                return expected_name.lower() in buf.value.lower()
+        return True
+    finally:
+        ctypes.windll.kernel32.CloseHandle(handle)
+
+
+def _state_file(version: str) -> Path:
+    # Normalize version string for filenames (e.g. "8.4" or "8.4.25")
+    return paths.RUN_DIR / f"php_{version}.json"
+
+
+def _load_state(version: str) -> list[WorkerState]:
+    f = _state_file(version)
+    if not f.exists():
+        return []
+    try:
+        raw = json.loads(f.read_text(encoding="utf-8"))
+        workers = [WorkerState(**w) for w in raw]
+    except Exception:
+        return []
+    
+    # Filter out dead workers and recycled PIDs
+    alive_workers = [w for w in workers if is_pid_alive(w.pid, expected_name="php-cgi")]
+    if len(alive_workers) != len(workers):
+        if alive_workers:
+            _save_state(version, alive_workers)
+        else:
+            f.unlink(missing_ok=True)
+    return alive_workers
+
+
+def _save_state(version: str, workers: list[WorkerState]) -> None:
+    paths.ensure_dirs()
+    _state_file(version).write_text(json.dumps([asdict(w) for w in workers], indent=2), encoding="utf-8")
+
+
+def ports_for(version: str, count: int, base_port: int) -> list[int]:
+    """
+    Deterministic, non-overlapping port block per version so multiple
+    PHP versions can run their pools simultaneously without port collisions.
+    Allocates up to 30 workers per minor version without overlap.
+    """
+    clean_ver = version.split()[0]
+    parts = clean_ver.split(".")
+    try:
+        major = int(parts[0])
+        minor = int(parts[1]) if len(parts) > 1 else 0
+        offset = (major * 500 + minor * 30)
+    except (ValueError, IndexError):
+        import zlib
+        offset = (zlib.crc32(clean_ver.encode("utf-8")) % 50) * 50
+    return [base_port + offset + i for i in range(count)]
+
+
+def _wait_for_ports(ports: list[int], timeout: float = 3.0) -> bool:
+    """Poll TCP ports until all are accepting connections or timeout occurs."""
+    import socket
+    import time
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        all_open = True
+        for port in ports:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.settimeout(0.1)
+                if s.connect_ex(("127.0.0.1", port)) != 0:
+                    all_open = False
+                    break
+        if all_open:
+            return True
+        time.sleep(0.05)
+    return False
+
+
+def start(version: str, php_cgi_path: Path, workers: int, base_port: int) -> list[WorkerState]:
+    current_state = _load_state(version)
+    if current_state:
+        return current_state
+
+    if not Path(php_cgi_path).exists():
+        raise FileNotFoundError(f"php-cgi.exe not found at {php_cgi_path}")
+
+    ports = ports_for(version, workers, base_port)
+    state: list[WorkerState] = []
+    
+    env = dict(os.environ)
+    env["PHP_FCGI_CHILDREN"] = "0"
+    env["PHP_FCGI_MAX_REQUESTS"] = "0"
+
+    for port in ports:
+        proc = subprocess.Popen(
+            [str(php_cgi_path), "-b", f"127.0.0.1:{port}"],
+            env=env,
+            cwd=str(php_cgi_path.parent),
+            creationflags=CREATE_NEW_PROCESS_GROUP | CREATE_NO_WINDOW,
+        )
+        state.append(WorkerState(pid=proc.pid, port=port))
+    
+    _wait_for_ports(ports)
+    _save_state(version, state)
+    return state
+
+
+def stop(version: str) -> None:
+    f = _state_file(version)
+    if not f.exists():
+        return
+    try:
+        raw = json.loads(f.read_text(encoding="utf-8"))
+        workers = [WorkerState(**w) for w in raw]
+    except Exception:
+        workers = []
+
+    for w in workers:
+        if not is_pid_alive(w.pid, expected_name="php-cgi"):
+            continue
+        terminated = False
+        try:
+            handle = ctypes.windll.kernel32.OpenProcess(PROCESS_TERMINATE, False, w.pid)
+            if handle:
+                ctypes.windll.kernel32.TerminateProcess(handle, 0)
+                ctypes.windll.kernel32.CloseHandle(handle)
+                terminated = True
+        except Exception:
+            pass
+        if not terminated or is_pid_alive(w.pid, expected_name="php-cgi"):
+            try:
+                subprocess.run(["taskkill.exe", "/F", "/PID", str(w.pid)], capture_output=True)
+            except Exception:
+                pass
+            
+    f.unlink(missing_ok=True)
+
+
+def restart(version: str, workers: int | None = None, base_port: int | None = None) -> list[WorkerState]:
+    # Local import to avoid circular imports
+    from . import php
+    cfg = paths.load_config()
+    n_workers = workers or cfg["fcgi_workers_per_version"]
+    port_base = base_port or cfg["fcgi_base_port"]
+    
+    stop(version)
+    return start(version, php.php_cgi_exe(version), n_workers, port_base)
+
+
+def status(version: str) -> list[WorkerState]:
+    return _load_state(version)
+
+
+def nginx_upstream_name(version: str, domain: str | None = None) -> str:
+    clean_ver = version.replace(".", "_")
+    if domain:
+        import re
+        clean_domain = re.sub(r"[^a-zA-Z0-9_]", "_", domain.strip().lower())
+        return f"php_{clean_ver}_{clean_domain}"
+    return f"php_{clean_ver}"
+
+
+def render_upstream_block(version: str, domain: str | None = None) -> str:
+    workers = status(version)
+    if not workers:
+        raise RuntimeError(f"PHP {version} pool is not running; start it first")
+    servers = "\n".join(f"    server 127.0.0.1:{w.port};" for w in workers)
+    u_name = nginx_upstream_name(version, domain=domain)
+    return f"upstream {u_name} {{\n{servers}\n}}\n"

ndev/win/core/grok.py

@@ -0,0 +1,55 @@
+"""
+ngrok tunnel wrapper for ndev-win virtual hosts.
+"""
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+from . import paths, vhost
+
+HTTP_PORT = 80
+HTTPS_PORT = 443
+
+
+def list_vhosts() -> list[str]:
+    """Return list of domain names with configured Nginx virtual hosts."""
+    return [v["domain"] for v in vhost.list_vhosts()]
+
+
+def _ngrok_exe() -> str:
+    # 1. Check shim dir
+    shim_exe = paths.SHIM_DIR / "ngrok.exe"
+    if shim_exe.exists():
+        return str(shim_exe)
+
+    # 2. Check config
+    cfg = paths.load_config()
+    path = cfg.get("ngrok_path")
+    if path and Path(path).exists():
+        return str(path)
+
+    # 3. Check system PATH
+    which_path = shutil.which("ngrok") or shutil.which("ngrok.exe")
+    if which_path:
+        return which_path
+
+    raise FileNotFoundError("ngrok isn't installed -- run `ndev setup` first")
+
+
+def start_tunnel(domain: str, ssl: bool = False) -> subprocess.Popen:
+    """
+    Start `ngrok http` against Nginx, rewriting Host header to `domain`.
+    """
+    import re
+    clean_domain = re.sub(r"^https?://", "", domain.strip().lower()).rstrip("/")
+    known = list_vhosts()
+    if clean_domain not in known:
+        raise FileNotFoundError(
+            f"No vhost found for '{clean_domain}'. Known vhosts: {known or '(none)'}"
+        )
+    target = f"https://localhost:{HTTPS_PORT}" if ssl else str(HTTP_PORT)
+    cmd = [_ngrok_exe(), "http", target, f"--host-header={clean_domain}"]
+    return subprocess.Popen(cmd)

ndev/win/core/logs.py

@@ -0,0 +1,66 @@
+"""
+Log viewing utilities for ndev-win.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+from . import paths, php
+
+
+def get_available_logs() -> dict[str, Path]:
+    """Return dictionary of log name -> log file Path."""
+    logs: dict[str, Path] = {}
+
+    # Nginx logs
+    if paths.NGINX_LOGS_DIR.exists():
+        for p in paths.NGINX_LOGS_DIR.glob("*.log"):
+            logs[f"nginx:{p.stem}"] = p
+
+    # MariaDB logs
+    if paths.MARIADB_DIR.exists():
+        data_dir = paths.MARIADB_DIR / "data"
+        if data_dir.exists():
+            for p in data_dir.glob("*.err"):
+                logs[f"mariadb:{p.stem}"] = p
+
+    # PHP logs (look in ~/.ndev/php/<version>/ or ~/.ndev/run/ / temp)
+    for v in php.list_installed():
+        v_dir = paths.version_dir(v)
+        for log_candidate in [v_dir / "php_error.log", v_dir / "error.log"]:
+            if log_candidate.exists():
+                logs[f"php:{v}"] = log_candidate
+
+    return logs
+
+
+def read_log_tail(log_path: Path, lines: int = 50) -> list[str]:
+    """Efficiently read the last N lines of a file without loading large files into memory."""
+    if not log_path.exists():
+        return []
+    try:
+        file_size = log_path.stat().st_size
+        if file_size == 0:
+            return []
+
+        # Read backward in chunks from the end of the file
+        chunk_size = 8192
+        chunks: list[bytes] = []
+        newlines_found = 0
+        with log_path.open("rb") as f:
+            pos = file_size
+            while pos > 0 and newlines_found <= lines:
+                read_len = min(chunk_size, pos)
+                pos -= read_len
+                f.seek(pos)
+                chunk = f.read(read_len)
+                chunks.append(chunk)
+                newlines_found += chunk.count(b"\n")
+
+        raw = b"".join(reversed(chunks))
+        text = raw.decode("utf-8", errors="ignore")
+        all_lines = text.splitlines()
+        return all_lines[-lines:]
+    except Exception:
+        return []

ndev/win/core/mailpit.py

@@ -0,0 +1,236 @@
+"""
+Mailpit - local email sandbox & SMTP catcher (https://github.com/axllent/mailpit).
+
+Downloads the prebuilt Windows binary from GitHub releases and manages the
+background process on Windows.
+
+SMTP server:  127.0.0.1:1025  (default)
+Web UI:       http://127.0.0.1:8025  (default)
+"""
+from __future__ import annotations
+
+import json
+import shutil
+import socket
+import subprocess
+import time
+import urllib.request
+import zipfile
+from pathlib import Path
+from typing import Optional
+
+from . import fcgi, paths
+
+# ── constants ────────────────────────────────────────────────────────────────
+
+GITHUB_REPO       = "axllent/mailpit"
+RELEASES_API_URL  = f"https://api.github.com/repos/{GITHUB_REPO}/releases/latest"
+RELEASES_PAGE_URL = f"https://github.com/{GITHUB_REPO}/releases"
+
+DEFAULT_SMTP_PORT = 1025
+DEFAULT_WEB_PORT  = 8025
+
+BINARY_NAME = "mailpit.exe"
+BINARY_PATH = paths.SHIM_DIR / BINARY_NAME
+
+_STATE_FILE = paths.RUN_DIR / "mailpit.json"
+
+CREATE_NEW_PROCESS_GROUP = 0x00000200
+CREATE_NO_WINDOW         = 0x08000000
+
+
+# ── helpers ──────────────────────────────────────────────────────────────────
+
+def is_installed() -> bool:
+    return BINARY_PATH.exists()
+
+
+def binary() -> Path:
+    if BINARY_PATH.exists():
+        return BINARY_PATH
+    raise FileNotFoundError(
+        "Mailpit binary not found. Run `ndev mailpit install` first."
+    )
+
+
+def _fetch_latest_release() -> dict:
+    req = urllib.request.Request(
+        RELEASES_API_URL,
+        headers={"User-Agent": "ndev/0.1.0"},
+    )
+    with urllib.request.urlopen(req, timeout=30) as resp:
+        return json.loads(resp.read())
+
+
+def _find_windows_asset(release: dict) -> Optional[dict]:
+    """Return the windows-amd64 asset, or None."""
+    for asset in release.get("assets", []):
+        name = asset["name"].lower()
+        if "windows" in name and "amd64" in name:
+            return asset
+    return None
+
+
+# ── core operations ──────────────────────────────────────────────────────────
+
+def install() -> Path:
+    """
+    Download the prebuilt Mailpit Windows binary from GitHub releases
+    and save it to ~/.ndev/shims/mailpit.exe.
+    """
+    paths.ensure_dirs()
+
+    release = _fetch_latest_release()
+    version = release.get("tag_name", "unknown")
+    asset   = _find_windows_asset(release)
+
+    if asset is None:
+        raise RuntimeError(
+            f"No prebuilt Windows binary found in Mailpit {version}.\n"
+            f"Check {RELEASES_PAGE_URL} for available assets."
+        )
+
+    url     = asset["browser_download_url"]
+    name    = asset["name"]
+    dl_path = paths.DOWNLOADS_DIR / name
+
+    # Download (skip if already cached)
+    if not dl_path.exists():
+        req = urllib.request.Request(url, headers={"User-Agent": "ndev/0.1.0"})
+        tmp = dl_path.with_suffix(".part")
+        with urllib.request.urlopen(req, timeout=180) as resp, open(tmp, "wb") as f:
+            shutil.copyfileobj(resp, f)
+        tmp.rename(dl_path)
+
+    # Extract .exe from zip
+    with zipfile.ZipFile(dl_path) as zf:
+        for member in zf.namelist():
+            if member.lower().endswith(".exe") and "mailpit" in member.lower():
+                with zf.open(member) as src, open(BINARY_PATH, "wb") as dst:
+                    shutil.copyfileobj(src, dst)
+                break
+        else:
+            raise RuntimeError(f"Could not find mailpit.exe inside {name}")
+
+    return BINARY_PATH
+
+
+def start(
+    smtp_port: int = DEFAULT_SMTP_PORT,
+    web_port: int = DEFAULT_WEB_PORT,
+) -> int:
+    """Start Mailpit in the background. Returns PID."""
+    exe = binary()
+
+    st = status()
+    if st:
+        raise RuntimeError(
+            f"Mailpit is already running at http://127.0.0.1:{st['web_port']} "
+            f"(PID {st['pid']})"
+        )
+
+    for port, label in [(smtp_port, "SMTP"), (web_port, "Web UI")]:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.settimeout(0.5)
+            if s.connect_ex(("127.0.0.1", port)) == 0:
+                raise RuntimeError(
+                    f"Port {port} ({label}) is already in use. "
+                    "Choose a different port or stop the conflicting service."
+                )
+
+    db_path = paths.NDEV_HOME / "mailpit.db"
+    cmd = [
+        str(exe),
+        "--smtp",     f"127.0.0.1:{smtp_port}",
+        "--listen",   f"127.0.0.1:{web_port}",
+        "--database", str(db_path),
+    ]
+
+    proc = subprocess.Popen(
+        cmd,
+        creationflags=CREATE_NEW_PROCESS_GROUP | CREATE_NO_WINDOW,
+    )
+
+    time.sleep(1.0)
+    if proc.poll() is not None:
+        raise RuntimeError(
+            "Mailpit exited immediately after launch. "
+            "Check for port conflicts or run `mailpit --help` manually."
+        )
+
+    paths.ensure_dirs()
+    state = {
+        "pid":       proc.pid,
+        "smtp_port": smtp_port,
+        "web_port":  web_port,
+        "url":       f"http://127.0.0.1:{web_port}",
+        "smtp":      f"127.0.0.1:{smtp_port}",
+        "database":  str(db_path),
+    }
+    _STATE_FILE.write_text(json.dumps(state, indent=2), encoding="utf-8")
+    return proc.pid
+
+
+def stop() -> None:
+    """Stop the running Mailpit process."""
+    import ctypes
+    if not _STATE_FILE.exists():
+        return
+    try:
+        state = json.loads(_STATE_FILE.read_text(encoding="utf-8"))
+        pid = state.get("pid")
+        if pid and fcgi.is_pid_alive(pid):
+            terminated = False
+            try:
+                handle = ctypes.windll.kernel32.OpenProcess(0x0001, False, pid)
+                if handle:
+                    ctypes.windll.kernel32.TerminateProcess(handle, 0)
+                    ctypes.windll.kernel32.CloseHandle(handle)
+                    terminated = True
+            except Exception:
+                pass
+            if not terminated or fcgi.is_pid_alive(pid):
+                subprocess.run(
+                    ["taskkill.exe", "/F", "/PID", str(pid), "/T"],
+                    capture_output=True,
+                )
+    except Exception:
+        pass
+    _STATE_FILE.unlink(missing_ok=True)
+
+
+def status() -> dict | None:
+    """Return the current state dict if Mailpit is running, else None."""
+    if not _STATE_FILE.exists():
+        return None
+    try:
+        state = json.loads(_STATE_FILE.read_text(encoding="utf-8"))
+        pid = state.get("pid")
+        if pid and fcgi.is_pid_alive(pid):
+            return state
+    except Exception:
+        pass
+    _STATE_FILE.unlink(missing_ok=True)
+    return None
+
+
+def restart(
+    smtp_port: int = DEFAULT_SMTP_PORT,
+    web_port: int = DEFAULT_WEB_PORT,
+) -> int:
+    """Stop (if running) then start Mailpit. Returns new PID."""
+    stop()
+    # Wait up to 3 s for the ports to be released
+    for _ in range(6):
+        ports_busy = False
+        for p in (smtp_port, web_port):
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.settimeout(0.3)
+                if s.connect_ex(("127.0.0.1", p)) == 0:
+                    ports_busy = True
+                    break
+        if not ports_busy:
+            break
+        time.sleep(0.5)
+    return start(smtp_port=smtp_port, web_port=web_port)
+

ndev/win/core/mkcert.py

@@ -0,0 +1,65 @@
+"""
+mkcert wrapper for local SSL certificates on Windows.
+"""
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+
+from . import paths
+
+_CA_INSTALLED_MARKER = paths.NDEV_HOME / ".mkcert-ca-installed"
+
+
+def _mkcert_path() -> str:
+    # 1. Check shim dir
+    shim_exe = paths.SHIM_DIR / "mkcert.exe"
+    if shim_exe.exists():
+        return str(shim_exe)
+
+    # 2. Check config
+    cfg = paths.load_config()
+    path = cfg.get("mkcert_path")
+    if path and Path(path).exists():
+        return str(path)
+
+    # 3. Check system PATH
+    which_path = shutil.which("mkcert") or shutil.which("mkcert.exe")
+    if which_path:
+        return which_path
+
+    raise FileNotFoundError("mkcert isn't installed -- run `ndev setup` first")
+
+
+def is_ca_installed() -> bool:
+    return _CA_INSTALLED_MARKER.exists()
+
+
+def ensure_ca_installed() -> None:
+    if _CA_INSTALLED_MARKER.exists():
+        return
+    subprocess.run([_mkcert_path(), "-install"], check=True)
+    paths.ensure_dirs()
+    _CA_INSTALLED_MARKER.write_text("ok", encoding="utf-8")
+
+
+def generate_cert(domain: str) -> tuple[str, str]:
+    """
+    Generates <domain>.crt and <domain>.key under ~/.ndev/certs/<domain>/.
+    Returns (cert_path, key_path) as strings with forward slashes for Nginx.
+    """
+    import re
+    clean_domain = re.sub(r"^https?://", "", domain.strip().lower()).rstrip("/")
+    ensure_ca_installed()
+    cert_dir = paths.CERTS_DIR / clean_domain
+    cert_dir.mkdir(parents=True, exist_ok=True)
+    cert_path = cert_dir / f"{clean_domain}.crt"
+    key_path = cert_dir / f"{clean_domain}.key"
+
+    if not (cert_path.exists() and key_path.exists()):
+        subprocess.run(
+            [_mkcert_path(), "-cert-file", str(cert_path), "-key-file", str(key_path), clean_domain, f"*.{clean_domain}"],
+            check=True,
+        )
+    return str(cert_path).replace("\\", "/"), str(key_path).replace("\\", "/")