ndev-stack 0.3.0__tar.gz → 0.3.1__tar.gz

{ndev_stack-0.3.0 → ndev_stack-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ndev-stack
-Version: 0.3.0
+Version: 0.3.1
 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
@@ -244,6 +244,7 @@ ndev ui
 | `ndev upgrade` | Check for and upgrade stack components (Nginx, MariaDB, Redis, PMA, Mailpit, mkcert, Composer) |
 | `ndev upgrade --check` | Check component versions against upstream releases without upgrading |
 | `ndev shell` | Interactive developer subshell pre-loaded with PHP/Composer/MySQL/Redis on PATH |
+| `ndev shim` | Manage Windows binary shims and PATH registration (`list`, `init`, `add`, `rm`) |
 | `ndev doctor` | Run environment diagnostics and health checks |
 | `ndev logs` | View and tail service and virtual host logs |
 | `ndev clean` | Clean up downloads cache and stale runtime state |

{ndev_stack-0.3.0 → ndev_stack-0.3.1}/README.md

@@ -223,6 +223,7 @@ ndev ui
 | `ndev upgrade` | Check for and upgrade stack components (Nginx, MariaDB, Redis, PMA, Mailpit, mkcert, Composer) |
 | `ndev upgrade --check` | Check component versions against upstream releases without upgrading |
 | `ndev shell` | Interactive developer subshell pre-loaded with PHP/Composer/MySQL/Redis on PATH |
+| `ndev shim` | Manage Windows binary shims and PATH registration (`list`, `init`, `add`, `rm`) |
 | `ndev doctor` | Run environment diagnostics and health checks |
 | `ndev logs` | View and tail service and virtual host logs |
 | `ndev clean` | Clean up downloads cache and stale runtime state |

{ndev_stack-0.3.0 → ndev_stack-0.3.1}/ndev/__init__.py

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

{ndev_stack-0.3.0 → ndev_stack-0.3.1}/ndev/common/modules/builtin/mongodb/module.py

@@ -119,16 +119,21 @@ class Module:
             except Exception:
                 pass
 
-            # Copy tools to ~/.ndev/shims/
+            # Create tool shims in ~/.ndev/shims/
             shim_dir = self.module_dir.parent.parent / "shims"
             if shim_dir.exists():
                 for tool in ["mongod.exe", "mongos.exe", "mongosh.exe"]:
                     src_tool = self.bin_dir / tool
                     if src_tool.exists():
+                        name = tool[:-4] if tool.lower().endswith(".exe") else tool
                         try:
-                            shutil.copy2(src_tool, shim_dir / tool)
+                            from ndev.win.core import shim as win_shim
+                            win_shim.create(name, str(src_tool), path_prepend=str(self.bin_dir), shim_dir=shim_dir)
                         except Exception:
-                            pass
+                            try:
+                                shutil.copy2(src_tool, shim_dir / tool)
+                            except Exception:
+                                pass
         else:
             # Linux: try installing via system package manager or apt
             if not shutil.which("mongod"):

{ndev_stack-0.3.0 → ndev_stack-0.3.1}/ndev/common/modules/builtin/postgres/module.py

@@ -108,16 +108,21 @@ class Module:
                 except Exception:
                     pass
 
-            # Copy key cli binaries to ~/.ndev/shims/
+            # Create key cli binary shims in ~/.ndev/shims/
             shim_dir = self.module_dir.parent.parent / "shims"
             if shim_dir.exists():
                 for tool in ["psql.exe", "pg_ctl.exe", "pg_dump.exe", "createdb.exe", "dropdb.exe"]:
                     src_tool = self.bin_dir / tool
                     if src_tool.exists():
+                        name = tool[:-4] if tool.lower().endswith(".exe") else tool
                         try:
-                            shutil.copy2(src_tool, shim_dir / tool)
+                            from ndev.win.core import shim as win_shim
+                            win_shim.create(name, str(src_tool), path_prepend=str(self.bin_dir), shim_dir=shim_dir)
                         except Exception:
-                            pass
+                            try:
+                                shutil.copy2(src_tool, shim_dir / tool)
+                            except Exception:
+                                pass
         else:
             # Linux: try installing via system package manager
             if not shutil.which("pg_ctl"):

{ndev_stack-0.3.0 → ndev_stack-0.3.1}/ndev/win/cli.py

@@ -33,6 +33,7 @@ from .core import (
     redis_core,
     services,
     setup as setup_core,
+    shim,
     upgrade as upgrade_core,
     vhost as vhost_core,
 )
@@ -375,8 +376,8 @@ def doctor():
         table.add_row("ngrok Tunneling", "[yellow]MISSING[/yellow]", "Run `ndev setup` to install")
 
     # Composer
-    composer_bat = paths.SHIM_DIR / "composer.bat"
-    if composer_bat.exists() or shutil.which("composer"):
+    composer_cmd = paths.SHIM_DIR / "composer.exe"
+    if composer_cmd.exists() or shutil.which("composer"):
         table.add_row("Composer", "[green]OK[/green]", "Installed and available on CLI")
     else:
         table.add_row("Composer", "[yellow]MISSING[/yellow]", "Run `ndev setup` to install")
@@ -390,7 +391,7 @@ def doctor():
     # PATH Check
     shim_on_path = str(paths.SHIM_DIR).lower() in os.environ.get("PATH", "").lower()
     path_status = "[green]OK[/green]" if shim_on_path else "[yellow]WARNING[/yellow]"
-    path_detail = f"Found on PATH ({paths.SHIM_DIR})" if shim_on_path else f"Add {paths.SHIM_DIR} to your system PATH"
+    path_detail = f"Found on PATH ({paths.SHIM_DIR})" if shim_on_path else f"Run `ndev shim init` or add {paths.SHIM_DIR} to PATH"
     table.add_row("Shims on PATH", path_status, path_detail)
 
     console.print(table)
@@ -1994,9 +1995,10 @@ def setup(nginx, mariadb, mkcert, ngrok, composer, cacert, nginx_version, mariad
     for name, path in results.items():
         console.print(f"[bold green]✓[/bold green] Installed {name:<10} -> {path}")
 
+    shim.ensure_on_path()
     shim_on_path = str(paths.SHIM_DIR).lower() in os.environ.get("PATH", "").lower()
     if not shim_on_path:
-        console.print(f"\n[bold yellow]Important:[/bold yellow] Add [bold cyan]{paths.SHIM_DIR}[/bold cyan] to your system PATH.")
+        console.print(f"\n[bold green]✓[/bold green] Added [bold cyan]{paths.SHIM_DIR}[/bold cyan] to User PATH (open a new terminal to use shims).")
 
 
 # ---- Component Upgrade (upgrade) --------------------------------------------
@@ -2372,6 +2374,78 @@ def mongodb_status_cmd():
     console.print(f"MongoDB: {'[bold green]RUNNING[/bold green]' if st.get('running') else '[bold red]STOPPED[/bold red]'} ({st.get('details', '')})")
 
 
+# ---- Shim Management (shim / shims) -----------------------------------------
+
+@main.group(name="shim")
+def shim_cmd():
+    """Manage Windows executable shims and PATH registration."""
+    pass
+
+
+@shim_cmd.command(name="list")
+def shim_list_cmd():
+    """List all configured shims."""
+    shims = shim.list_shims()
+    if not shims:
+        console.print("[yellow]No shims configured in ~/.ndev/shims.[/yellow]")
+        return
+
+    table = Table(title="ndev Windows Shims")
+    table.add_column("Command", style="bold cyan")
+    table.add_column("Target Executable / Details", style="green")
+    for name, target in shims.items():
+        table.add_row(name, target)
+    console.print(table)
+
+
+@shim_cmd.command(name="init")
+def shim_init_cmd():
+    """Ensure ~/.ndev/shims is added to the user PATH environment variable."""
+    updated = shim.ensure_on_path()
+    if updated:
+        console.print(f"[bold green]✓ Added {paths.SHIM_DIR} to User PATH registry.[/bold green]")
+        console.print("[dim]A WM_SETTINGCHANGE broadcast was sent. Open a new terminal to use shims.[/dim]")
+    else:
+        console.print(f"[green]✓ {paths.SHIM_DIR} is already present in your User PATH registry.[/green]")
+
+
+@shim_cmd.command(name="add")
+@click.argument("name")
+@click.argument("target")
+@click.option("--args", default="", help="Default arguments to pass to target executable")
+@click.option("--cwd", default=None, help="Working directory for execution")
+@click.option("--prepend", default=None, help="Directory to prepend to PATH for target")
+def shim_add_cmd(name, target, args, cwd, prepend):
+    """Create or update a custom native Windows .exe shim."""
+    try:
+        created = shim.create(name, target, args=args, cwd=cwd, path_prepend=prepend)
+        console.print(f"[bold green]✓ Created shim '{name}' -> {created}[/bold green]")
+    except Exception as e:
+        raise click.ClickException(str(e))
+
+
+@shim_cmd.command(name="rm")
+@click.argument("name")
+def shim_rm_cmd(name):
+    """Remove a shim."""
+    if shim.remove(name):
+        console.print(f"[bold green]✓ Removed shim '{name}'.[/bold green]")
+    else:
+        console.print(f"[yellow]No shim named '{name}' found.[/yellow]")
+
+
+@main.group(name="shims", hidden=True)
+def shims_alias():
+    """Alias for shim."""
+    pass
+
+
+shims_alias.add_command(shim_list_cmd, "list")
+shims_alias.add_command(shim_init_cmd, "init")
+shims_alias.add_command(shim_add_cmd, "add")
+shims_alias.add_command(shim_rm_cmd, "rm")
+
+
 if __name__ == "__main__":
     sys.exit(main())
 

{ndev_stack-0.3.0 → ndev_stack-0.3.1}/ndev/win/core/php.py

@@ -15,7 +15,7 @@ from pathlib import Path
 
 import httpx
 
-from . import paths
+from . import paths, shim
 
 RELEASES_INDEX_URL = "https://windows.php.net/downloads/releases/releases.json"
 ARCHIVES_INDEX_URL = "https://windows.php.net/downloads/releases/archives/"
@@ -498,12 +498,9 @@ def uninstall(version: str) -> None:
             if paths.CURRENT_FILE.exists():
                 paths.CURRENT_FILE.unlink(missing_ok=True)
             # Remove all PHP and Composer shims
-            for shim in [
-                "php.bat", "php.cmd", "php.ps1",
-                "php-cgi.bat", "php-cgi.cmd", "php-cgi.ps1",
-                "composer.bat", "composer.cmd", "composer.ps1",
-            ]:
-                (paths.SHIM_DIR / shim).unlink(missing_ok=True)
+            shim.remove("php")
+            shim.remove("php-cgi")
+            shim.remove("composer")
 
 
 def list_installed() -> list[str]:
@@ -570,37 +567,30 @@ def get_current_version() -> str | None:
 def use(version: str) -> str:
     """
     Point ndev shims (on PATH) at this version's php.exe and php-cgi.exe.
-    Generates php.bat, php.cmd, php-cgi.bat, and composer.bat in ~/.ndev/shims.
+    Generates binary .exe shims with .cmd fallback in ~/.ndev/shims.
     Returns the resolved version string.
     """
     resolved_ver = resolve_installed(version)
     paths.ensure_dirs()
     
-    exe_path = str(paths.version_dir(resolved_ver) / "php.exe")
-    cgi_path = str(paths.version_dir(resolved_ver) / "php-cgi.exe")
+    php_dir = paths.version_dir(resolved_ver)
+    exe_path = str(php_dir / "php.exe")
+    cgi_path = str(php_dir / "php-cgi.exe")
 
-    # php.bat, php.cmd, php.ps1
-    (paths.SHIM_DIR / "php.bat").write_text(f'@echo off\r\n"{exe_path}" %*\r\n', encoding="utf-8")
-    (paths.SHIM_DIR / "php.cmd").write_text(f'@echo off\r\n"{exe_path}" %*\r\n', encoding="utf-8")
-    (paths.SHIM_DIR / "php.ps1").write_text(f'& "{exe_path}" @args\r\n', encoding="utf-8")
+    # Create native shims via shimgen with path_prepend for PHP DLLs (cleans any legacy scripts)
+    shim.create("php", exe_path, path_prepend=str(php_dir), clean_legacy=True)
+    shim.create("php-cgi", cgi_path, path_prepend=str(php_dir), clean_legacy=True)
 
-    # php-cgi.bat, php-cgi.cmd, php-cgi.ps1
-    (paths.SHIM_DIR / "php-cgi.bat").write_text(f'@echo off\r\n"{cgi_path}" %*\r\n', encoding="utf-8")
-    (paths.SHIM_DIR / "php-cgi.cmd").write_text(f'@echo off\r\n"{cgi_path}" %*\r\n', encoding="utf-8")
-    (paths.SHIM_DIR / "php-cgi.ps1").write_text(f'& "{cgi_path}" @args\r\n', encoding="utf-8")
-
-    # If composer.phar is present, create/update composer shims
+    # If composer.phar is present, create/update composer native shim
     composer_phar = paths.SHIM_DIR / "composer.phar"
     if composer_phar.exists():
         clean_phar = str(composer_phar.resolve()).replace("\\", "/")
-        (paths.SHIM_DIR / "composer.bat").write_text(
-            f'@echo off\r\n"{exe_path}" "{clean_phar}" %*\r\n', encoding="utf-8"
-        )
-        (paths.SHIM_DIR / "composer.cmd").write_text(
-            f'@echo off\r\n"{exe_path}" "{clean_phar}" %*\r\n', encoding="utf-8"
-        )
-        (paths.SHIM_DIR / "composer.ps1").write_text(
-            f'& "{exe_path}" "{clean_phar}" @args\r\n', encoding="utf-8"
+        shim.create(
+            "composer",
+            exe_path,
+            args=f'"{clean_phar}"',
+            path_prepend=str(php_dir),
+            clean_legacy=True,
         )
 
     paths.set_current_version(resolved_ver)

{ndev_stack-0.3.0 → ndev_stack-0.3.1}/ndev/win/core/redis_core.py

@@ -16,7 +16,7 @@ import time
 import zipfile
 from pathlib import Path
 
-from . import fcgi, paths, setup as setup_core
+from . import fcgi, paths, setup as setup_core, shim
 
 DEFAULT_PORT = 6379
 DEFAULT_VERSION = "8.10.1"
@@ -103,12 +103,15 @@ def install(version: str = DEFAULT_VERSION) -> Path:
         )
 
     # Place redis-cli shim in ~/.ndev/shims/
-    if (REDIS_DIR / "redis-cli.exe").exists():
-        shim_cli = paths.SHIM_DIR / "redis-cli.exe"
+    cli_file = REDIS_DIR / "redis-cli.exe"
+    if cli_file.exists():
         try:
-            shutil.copy2(REDIS_DIR / "redis-cli.exe", shim_cli)
+            shim.create("redis-cli", str(cli_file), path_prepend=str(REDIS_DIR))
         except Exception:
-            pass
+            try:
+                shutil.copy2(cli_file, paths.SHIM_DIR / "redis-cli.exe")
+            except Exception:
+                pass
 
     return REDIS_DIR
 

{ndev_stack-0.3.0 → ndev_stack-0.3.1}/ndev/win/core/setup.py

@@ -12,7 +12,7 @@ from typing import Optional
 
 import httpx
 
-from . import paths
+from . import paths, shim
 
 # ---- Defaults ---------------------------------------------------------------
 
@@ -170,16 +170,13 @@ def install_mariadb(version: str = DEFAULT_MARIADB_VERSION) -> Path:
 
 def _create_mariadb_shims() -> None:
     paths.ensure_dirs()
-    mysql_exe = paths.MARIADB_DIR / "bin" / "mysql.exe"
-    mysqldump_exe = paths.MARIADB_DIR / "bin" / "mysqldump.exe"
+    bin_dir = paths.MARIADB_DIR / "bin"
+    mysql_exe = bin_dir / "mysql.exe"
+    mysqldump_exe = bin_dir / "mysqldump.exe"
     if mysql_exe.exists():
-        (paths.SHIM_DIR / "mysql.bat").write_text(f'@echo off\r\n"{mysql_exe}" %*\r\n', encoding="utf-8")
-        (paths.SHIM_DIR / "mysql.cmd").write_text(f'@echo off\r\n"{mysql_exe}" %*\r\n', encoding="utf-8")
-        (paths.SHIM_DIR / "mysql.ps1").write_text(f'& "{mysql_exe}" @args\r\n', encoding="utf-8")
+        shim.create("mysql", str(mysql_exe), path_prepend=str(bin_dir), clean_legacy=True)
     if mysqldump_exe.exists():
-        (paths.SHIM_DIR / "mysqldump.bat").write_text(f'@echo off\r\n"{mysqldump_exe}" %*\r\n', encoding="utf-8")
-        (paths.SHIM_DIR / "mysqldump.cmd").write_text(f'@echo off\r\n"{mysqldump_exe}" %*\r\n', encoding="utf-8")
-        (paths.SHIM_DIR / "mysqldump.ps1").write_text(f'& "{mysqldump_exe}" @args\r\n', encoding="utf-8")
+        shim.create("mysqldump", str(mysqldump_exe), path_prepend=str(bin_dir), clean_legacy=True)
 
 
 def _init_mariadb_data_dir() -> None:
@@ -280,14 +277,28 @@ def install_ngrok() -> Path:
 # ---- Composer -----------------------------------------------------------------
 
 def install_composer() -> Path:
-    """Download composer.phar and generate composer.bat, composer.cmd, and composer.ps1 shims."""
+    """Download composer.phar and generate native composer.exe shim."""
     phar_dest = paths.SHIM_DIR / "composer.phar"
     _download(COMPOSER_PHAR_URL, phar_dest)
     
     clean_phar = str(phar_dest.resolve()).replace("\\", "/")
-    (paths.SHIM_DIR / "composer.bat").write_text(f'@echo off\r\nphp "{clean_phar}" %*\r\n', encoding="utf-8")
-    (paths.SHIM_DIR / "composer.cmd").write_text(f'@echo off\r\nphp "{clean_phar}" %*\r\n', encoding="utf-8")
-    (paths.SHIM_DIR / "composer.ps1").write_text(f'& php "{clean_phar}" @args\r\n', encoding="utf-8")
+    # If active PHP is installed, point composer shim directly to it
+    from . import php
+    curr_ver = php.get_current_version()
+    if curr_ver:
+        try:
+            exe_path = str(paths.version_dir(curr_ver) / "php.exe")
+            shim.create(
+                "composer",
+                exe_path,
+                args=f'"{clean_phar}"',
+                path_prepend=str(paths.version_dir(curr_ver)),
+                clean_legacy=True,
+            )
+            return phar_dest
+        except Exception:
+            pass
+
     return phar_dest
 
 
@@ -306,25 +317,14 @@ def install_cacert() -> Path:
 
 
 def create_ndev_shims() -> Path:
-    """Create ndev.bat, ndev.cmd, and ndev.ps1 in ~/.ndev/shims/ pointing to active python/ndev."""
+    """Create ndev native executable shim in ~/.ndev/shims/ pointing to active python/ndev."""
     import sys
     paths.ensure_dirs()
     scripts_dir = Path(sys.executable).parent
     ndev_exe = scripts_dir / "ndev.exe"
     if ndev_exe.exists():
-        bat_target = f'"{ndev_exe}" %*'
-        ps_target = f'& "{ndev_exe}" @args'
-    else:
-        bat_target = f'"{sys.executable}" -m ndev_win.cli %*'
-        ps_target = f'& "{sys.executable}" -m ndev_win.cli @args'
-
-    bat_path = paths.SHIM_DIR / "ndev.bat"
-    cmd_path = paths.SHIM_DIR / "ndev.cmd"
-    ps_path = paths.SHIM_DIR / "ndev.ps1"
-    bat_path.write_text(f'@echo off\r\n{bat_target}\r\n', encoding="utf-8")
-    cmd_path.write_text(f'@echo off\r\n{bat_target}\r\n', encoding="utf-8")
-    ps_path.write_text(f'{ps_target}\r\n', encoding="utf-8")
-    return bat_path
+        return shim.create("ndev", str(ndev_exe), clean_legacy=True)
+    return shim.create("ndev", sys.executable, args="-m ndev.main", clean_legacy=True)
 
 
 # ---- Orchestration ----------------------------------------------------------

ndev_stack-0.3.1/ndev/win/core/shim.py

@@ -0,0 +1,284 @@
+"""
+shim generator and manager for ndev on Windows.
+
+Provides native Windows .exe shims using shim.exe + <name>.shim config pairs.
+"""
+from __future__ import annotations
+
+import filecmp
+import ntpath
+import os
+import re
+import shutil
+import sys
+import warnings
+from pathlib import Path
+
+from . import paths
+
+# By default, use ndev's central SHIM_DIR
+SHIM_DIR = paths.SHIM_DIR
+
+
+def _find_shim_exe() -> Path:
+    """Find prebuilt shim.exe binary across installed package or repository."""
+    # 1. Check explicit environment override
+    env_exe = os.environ.get("NDEV_SHIM_EXE")
+    if env_exe:
+        p = Path(env_exe)
+        if p.exists():
+            return p
+
+    # 2. Check bundled package binary (ndev/win/bin/shim.exe)
+    pkg_exe = Path(__file__).parent.parent / "bin" / "shim.exe"
+    if pkg_exe.exists():
+        return pkg_exe
+
+    # 3. Check development repository root (shimgen/shim.exe)
+    repo_exe = Path(__file__).resolve().parent.parent.parent.parent / "shimgen" / "shim.exe"
+    if repo_exe.exists():
+        return repo_exe
+
+    return pkg_exe
+
+
+SHIM_EXE = _find_shim_exe()
+
+_NAME_RE = re.compile(r"^[\w.+\-]+$")
+
+_RESERVED = {
+    "con", "prn", "aux", "nul",
+    *(f"com{i}" for i in range(1, 10)),
+    *(f"lpt{i}" for i in range(1, 10)),
+}
+
+
+def _check_name(name: str) -> str:
+    if (
+        not _NAME_RE.match(name)
+        or name.endswith(".")
+        or name.split(".")[0].lower() in _RESERVED
+    ):
+        raise ValueError(f"invalid shim name: {name!r}")
+    return name
+
+
+def _write(path: Path, text: str, encoding: str = "utf-8") -> None:
+    """Atomic write: a shim starting mid-update never sees a half-written file."""
+    tmp = path.with_name(f"{path.name}.tmp-{os.getpid()}")
+    with open(tmp, "w", encoding=encoding, newline="\r\n") as f:
+        f.write(text)
+    try:
+        os.replace(tmp, path)
+    except OSError:
+        # Fallback if target is momentarily locked
+        try:
+            if path.exists():
+                _unlink(path)
+            os.replace(tmp, path)
+        except OSError:
+            try:
+                tmp.unlink(missing_ok=True)
+            except OSError:
+                pass
+            raise
+
+
+def _unlink(p: Path) -> bool:
+    """Delete p. A running .exe can't be deleted on Windows but can be renamed,
+    so rename it out of the way and sweep it later."""
+    if not p.exists():
+        return False
+    try:
+        p.unlink()
+    except PermissionError:
+        try:
+            os.replace(p, p.with_name(f"{p.name}.old-{os.getpid()}"))
+        except OSError:
+            pass
+    except OSError:
+        return False
+    return True
+
+
+def _sweep(shim_dir: Path) -> None:
+    for p in shim_dir.glob("*.old-*"):
+        try:
+            p.unlink()
+        except OSError:
+            pass  # still running; sweep next time
+
+
+def _same(a: Path, b: Path) -> bool:
+    try:
+        return os.path.samefile(a, b) or filecmp.cmp(a, b, shallow=False)
+    except OSError:
+        return False
+
+
+def _install_exe(dst: Path) -> None:
+    if dst.exists():
+        if _same(SHIM_EXE, dst):
+            return  # already current (also avoids touching an exe that is running)
+        try:
+            os.replace(dst, dst.with_name(f"{dst.name}.old-{os.getpid()}"))
+        except OSError:
+            pass
+    try:
+        os.link(SHIM_EXE, dst)  # hard link: fast, zero disk copy overhead
+    except OSError:
+        shutil.copyfile(SHIM_EXE, dst)  # cross-volume or non-NTFS fallback
+
+
+def create(
+    name: str,
+    target: str | Path,
+    args: str = "",
+    cwd: str | Path | None = None,
+    env: dict[str, str] | None = None,
+    path_prepend: str | Path | None = None,
+    shim_dir: Path | None = None,
+    clean_legacy: bool = True,
+) -> Path:
+    """Create or update a native Windows .exe shim in shim_dir (defaults to ~/.ndev/shims).
+
+    Returns the path to the generated <shim_dir>/<name>.exe.
+    """
+    _check_name(name)
+    shim_dir = Path(shim_dir or SHIM_DIR)
+    shim_dir.mkdir(parents=True, exist_ok=True)
+    target = str(target)
+    env = env or {}
+
+    if not (ntpath.isabs(target) or target.startswith("%")):
+        raise ValueError(f"shim target must be an absolute Windows path, got {target!r}")
+    if not os.path.isfile(os.path.expandvars(target)):
+        warnings.warn(f"shim target does not exist (yet): {target}", stacklevel=2)
+
+    _sweep(shim_dir)
+
+    if not SHIM_EXE.is_file():
+        raise FileNotFoundError(f"shim.exe not found at {SHIM_EXE}; build or place shim.exe first")
+
+    lines = [f"path = {target}"]
+    if args:
+        lines.append(f"args = {args}")
+    if cwd:
+        lines.append(f"cwd = {cwd}")
+    if path_prepend:
+        lines.append(f"path_prepend = {path_prepend}")
+    lines += [f"env.{k} = {v}" for k, v in sorted(env.items())]
+
+    # Write config first, exe second: the exe never exists without its config
+    _write(shim_dir / f"{name}.shim", "\n".join(lines) + "\n")
+    _install_exe(shim_dir / f"{name}.exe")
+
+    # Clean legacy script shims (.cmd, .bat, .ps1)
+    if clean_legacy:
+        _unlink(shim_dir / f"{name}.cmd")
+        _unlink(shim_dir / f"{name}.bat")
+        _unlink(shim_dir / f"{name}.ps1")
+
+    return shim_dir / f"{name}.exe"
+
+
+def remove(name: str, shim_dir: Path | None = None) -> bool:
+    """Remove all shims and configs for `name` (.exe, .shim, .cmd, .bat, .ps1)."""
+    _check_name(name)
+    shim_dir = Path(shim_dir or SHIM_DIR)
+    removed = False
+    for ext in (".exe", ".shim", ".cmd", ".bat", ".ps1"):
+        removed |= _unlink(shim_dir / f"{name}{ext}")
+    return removed
+
+
+def read_shim(name: str, shim_dir: Path | None = None) -> dict[str, str]:
+    """Read a .shim config file into a dictionary."""
+    shim_dir = Path(shim_dir or SHIM_DIR)
+    cfg: dict[str, str] = {}
+    p = shim_dir / f"{name}.shim"
+    if p.exists():
+        try:
+            for line in p.read_text(encoding="utf-8-sig").splitlines():
+                line = line.strip()
+                if line and not line.startswith("#") and "=" in line:
+                    k, v = line.split("=", 1)
+                    cfg[k.strip()] = v.strip()
+        except OSError:
+            pass
+    return cfg
+
+
+def list_shims(shim_dir: Path | None = None) -> dict[str, str]:
+    """Return dict of {name: target_path_or_description} for all native shims."""
+    shim_dir = Path(shim_dir or SHIM_DIR)
+    if not shim_dir.is_dir():
+        return {}
+    out: dict[str, str] = {}
+
+    for p in sorted(shim_dir.iterdir()):
+        if p.suffix.lower() == ".exe" and (shim_dir / f"{p.stem}.shim").exists():
+            cfg = read_shim(p.stem, shim_dir)
+            t = cfg.get("path", "?")
+            out[p.stem] = (
+                t
+                if os.path.isfile(os.path.expandvars(t)) or sys.platform != "win32"
+                else f"{t}  [MISSING]"
+            )
+
+    return out
+
+
+def ensure_on_path(shim_dir: Path | None = None) -> bool:
+    """Add the shim directory to the HKCU user PATH registry if not already present.
+    Normalizes slashes/case, skips duplicate additions, and broadcasts WM_SETTINGCHANGE.
+    Returns True if user PATH was updated, False if already present.
+    """
+    if sys.platform != "win32":
+        return False
+
+    import ctypes
+    import winreg
+    from ctypes import wintypes
+
+    shim_dir_str = str(Path(shim_dir or SHIM_DIR).resolve())
+
+    def norm(p: str) -> str:
+        return os.path.normcase(os.path.normpath(os.path.expandvars(p.strip().rstrip("\\/"))))
+
+    norm_target = norm(shim_dir_str)
+
+    with winreg.OpenKey(
+        winreg.HKEY_CURRENT_USER, "Environment", 0, winreg.KEY_READ | winreg.KEY_WRITE
+    ) as key:
+        try:
+            cur, typ = winreg.QueryValueEx(key, "Path")
+        except FileNotFoundError:
+            cur, typ = "", winreg.REG_EXPAND_SZ
+
+        parts = [p.strip() for p in cur.split(";") if p.strip()]
+        if any(norm(p) == norm_target for p in parts):
+            return False
+
+        # Prepend to front so ndev shims take precedence
+        parts.insert(0, shim_dir_str)
+        winreg.SetValueEx(key, "Path", 0, typ, ";".join(parts))
+
+    try:
+        send = ctypes.windll.user32.SendMessageTimeoutW
+        send.argtypes = [
+            wintypes.HWND,
+            wintypes.UINT,
+            wintypes.WPARAM,
+            wintypes.LPCWSTR,
+            wintypes.UINT,
+            wintypes.UINT,
+            ctypes.POINTER(wintypes.DWORD),
+        ]
+        send.restype = wintypes.LPARAM
+        result = wintypes.DWORD()
+        send(0xFFFF, 0x001A, 0, "Environment", 2, 5000, ctypes.byref(result))  # HWND_BROADCAST, WM_SETTINGCHANGE
+    except Exception:
+        pass
+
+    return True

{ndev_stack-0.3.0 → ndev_stack-0.3.1}/ndev/win/core/upgrade.py

@@ -433,14 +433,15 @@ def get_composer_info() -> ComponentInfo:
 
     if installed:
         try:
-            bat = paths.SHIM_DIR / "composer.bat"
-            res = subprocess.run([str(bat), "--version", "--no-ansi"], capture_output=True, text=True, timeout=10)
-            raw = (res.stdout or "") + "\n" + (res.stderr or "")
-            # Strip ANSI escape sequences if any exist
-            clean_text = re.sub(r"\x1b\[[0-9;]*[a-zA-Z]", "", raw)
-            m = re.search(r"Composer\s+(?:version\s+)?(\d+\.\d+\.\d+)", clean_text, re.IGNORECASE)
-            if m:
-                curr_ver = m.group(1)
+            comp_cmd = paths.SHIM_DIR / "composer.exe"
+            if comp_cmd.exists():
+                res = subprocess.run([str(comp_cmd), "--version", "--no-ansi"], capture_output=True, text=True, timeout=10)
+                raw = (res.stdout or "") + "\n" + (res.stderr or "")
+                # Strip ANSI escape sequences if any exist
+                clean_text = re.sub(r"\x1b\[[0-9;]*[a-zA-Z]", "", raw)
+                m = re.search(r"Composer\s+(?:version\s+)?(\d+\.\d+\.\d+)", clean_text, re.IGNORECASE)
+                if m:
+                    curr_ver = m.group(1)
         except Exception as e:
             err = str(e)
 
@@ -469,9 +470,9 @@ def get_composer_info() -> ComponentInfo:
 
 def upgrade_composer() -> tuple[bool, str]:
     try:
-        bat = paths.SHIM_DIR / "composer.bat"
-        if bat.exists():
-            res = subprocess.run([str(bat), "self-update"], capture_output=True, text=True, timeout=60)
+        comp_cmd = paths.SHIM_DIR / "composer.exe"
+        if comp_cmd.exists():
+            res = subprocess.run([str(comp_cmd), "self-update"], capture_output=True, text=True, timeout=60)
             if res.returncode == 0:
                 info = get_composer_info()
                 return True, f"Composer upgraded successfully ({info.current_version})."

{ndev_stack-0.3.0 → ndev_stack-0.3.1}/ndev_stack.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ndev-stack
-Version: 0.3.0
+Version: 0.3.1
 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
@@ -244,6 +244,7 @@ ndev ui
 | `ndev upgrade` | Check for and upgrade stack components (Nginx, MariaDB, Redis, PMA, Mailpit, mkcert, Composer) |
 | `ndev upgrade --check` | Check component versions against upstream releases without upgrading |
 | `ndev shell` | Interactive developer subshell pre-loaded with PHP/Composer/MySQL/Redis on PATH |
+| `ndev shim` | Manage Windows binary shims and PATH registration (`list`, `init`, `add`, `rm`) |
 | `ndev doctor` | Run environment diagnostics and health checks |
 | `ndev logs` | View and tail service and virtual host logs |
 | `ndev clean` | Clean up downloads cache and stale runtime state |

{ndev_stack-0.3.0 → ndev_stack-0.3.1}/ndev_stack.egg-info/SOURCES.txt

@@ -69,6 +69,7 @@ ndev/linux/runtime/upgrade.py
 ndev/win/__init__.py
 ndev/win/cli.py
 ndev/win/tui.py
+ndev/win/bin/shim.exe
 ndev/win/commands/__init__.py
 ndev/win/core/__init__.py
 ndev/win/core/db.py
@@ -85,6 +86,7 @@ ndev/win/core/pma.py
 ndev/win/core/redis_core.py
 ndev/win/core/services.py
 ndev/win/core/setup.py
+ndev/win/core/shim.py
 ndev/win/core/upgrade.py
 ndev/win/core/vhost.py
 ndev/win/templates/vhost.conf.tmpl
@@ -94,4 +96,5 @@ ndev_stack.egg-info/SOURCES.txt
 ndev_stack.egg-info/dependency_links.txt
 ndev_stack.egg-info/entry_points.txt
 ndev_stack.egg-info/requires.txt
-ndev_stack.egg-info/top_level.txt
+ndev_stack.egg-info/top_level.txt
+tests/test_shim.py

{ndev_stack-0.3.0 → ndev_stack-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ndev-stack"
-version = "0.3.0"
+version = "0.3.1"
 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"
@@ -41,5 +41,5 @@ where = ["."]
 include = ["ndev*"]
 
 [tool.setuptools.package-data]
-"*" = ["*.tmpl", "*.conf", "*.json", "*.ini", "*.php", "*.md"]
+"*" = ["*.tmpl", "*.conf", "*.json", "*.ini", "*.php", "*.md", "*.exe"]
 

ndev_stack-0.3.1/tests/test_shim.py

@@ -0,0 +1,86 @@
+"""
+Tests for ndev.win.core.shim (Windows shimgen integration).
+"""
+import os
+import shutil
+import tempfile
+import unittest
+from pathlib import Path
+
+from ndev.win.core import shim
+
+
+class TestShim(unittest.TestCase):
+    def setUp(self):
+        self.test_dir = Path(tempfile.mkdtemp(prefix="ndev_shim_test_"))
+
+    def tearDown(self):
+        shutil.rmtree(self.test_dir, ignore_errors=True)
+
+    def test_shim_exe_exists(self):
+        self.assertTrue(shim.SHIM_EXE.exists(), f"shim.exe not found at {shim.SHIM_EXE}")
+
+    def test_create_and_read_exe_shim(self):
+        # Target dummy executable
+        target_path = Path(r"C:\Windows\System32\cmd.exe")
+        shim_file = shim.create(
+            "dummy_cmd",
+            target_path,
+            args="/c echo hello",
+            cwd=r"C:\Windows",
+            path_prepend=r"C:\Windows\System32",
+            shim_dir=self.test_dir,
+        )
+
+        self.assertEqual(shim_file, self.test_dir / "dummy_cmd.exe")
+        self.assertTrue((self.test_dir / "dummy_cmd.exe").exists())
+        self.assertTrue((self.test_dir / "dummy_cmd.shim").exists())
+
+        cfg = shim.read_shim("dummy_cmd", shim_dir=self.test_dir)
+        self.assertEqual(cfg.get("path"), str(target_path))
+        self.assertEqual(cfg.get("args"), "/c echo hello")
+        self.assertEqual(cfg.get("cwd"), r"C:\Windows")
+        self.assertEqual(cfg.get("path_prepend"), r"C:\Windows\System32")
+
+    def test_list_and_remove_shim(self):
+        target_path = Path(r"C:\Windows\System32\cmd.exe")
+        shim.create("tool_a", target_path, shim_dir=self.test_dir)
+        shim.create("tool_b", target_path, shim_dir=self.test_dir)
+
+        shims = shim.list_shims(shim_dir=self.test_dir)
+        self.assertIn("tool_a", shims)
+        self.assertIn("tool_b", shims)
+
+        removed = shim.remove("tool_a", shim_dir=self.test_dir)
+        self.assertTrue(removed)
+        self.assertFalse((self.test_dir / "tool_a.exe").exists())
+        self.assertFalse((self.test_dir / "tool_a.shim").exists())
+
+        shims_after = shim.list_shims(shim_dir=self.test_dir)
+        self.assertNotIn("tool_a", shims_after)
+        self.assertIn("tool_b", shims_after)
+
+    def test_clean_legacy_option(self):
+        target_path = Path(r"C:\Windows\System32\cmd.exe")
+        # Create mock legacy .bat, .cmd, and .ps1
+        (self.test_dir / "preserve_test.bat").write_text("@echo off", encoding="utf-8")
+        (self.test_dir / "preserve_test.cmd").write_text("@echo off", encoding="utf-8")
+        (self.test_dir / "preserve_test.ps1").write_text("& echo hi", encoding="utf-8")
+
+        # When clean_legacy is False, legacy files remain
+        shim.create("preserve_test", target_path, shim_dir=self.test_dir, clean_legacy=False)
+        self.assertTrue((self.test_dir / "preserve_test.exe").exists())
+        self.assertTrue((self.test_dir / "preserve_test.bat").exists())
+        self.assertTrue((self.test_dir / "preserve_test.cmd").exists())
+        self.assertTrue((self.test_dir / "preserve_test.ps1").exists())
+
+        # When clean_legacy is True, legacy files are unlinked
+        shim.create("preserve_test", target_path, shim_dir=self.test_dir, clean_legacy=True)
+        self.assertTrue((self.test_dir / "preserve_test.exe").exists())
+        self.assertFalse((self.test_dir / "preserve_test.bat").exists())
+        self.assertFalse((self.test_dir / "preserve_test.cmd").exists())
+        self.assertFalse((self.test_dir / "preserve_test.ps1").exists())
+
+
+if __name__ == "__main__":
+    unittest.main()