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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ndev-stack
-Version: 0.3.0
+Version: 0.3.2
 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.2}/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.2}/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.2"
 
 from . import common as common
 from .common.logger import logger as logger

{ndev_stack-0.3.0 → ndev_stack-0.3.2}/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.2}/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.2/ndev/linux/commands/grok.py

@@ -0,0 +1,97 @@
+import tempfile
+import subprocess
+import shutil
+import typer
+from pathlib import Path
+from rich.console import Console
+from ndev.common.logger import logger
+
+console = Console()
+
+def get_vhost_info() -> list[dict]:
+    nginx_dir = Path("/etc/nginx/sites-enabled")
+    vhosts = []
+    if not nginx_dir.exists():
+        return vhosts
+        
+    for file in nginx_dir.glob("*.conf"):
+        try:
+            content = file.read_text()
+            domain = None
+            for line in content.splitlines():
+                line = line.strip()
+                if line.startswith("server_name"):
+                    parts = line.split()
+                    for p in parts[1:]:
+                        p = p.rstrip(";").strip()
+                        if p and p != "_":
+                            domain = p
+                            break
+                    if domain:
+                        break
+            if domain:
+                has_ssl = "listen 443 ssl" in content or "listen [::]:443 ssl" in content
+                vhosts.append({"domain": domain, "ssl": has_ssl})
+        except Exception:
+            pass
+    return vhosts
+
+def grok_cmd():
+    """Proxy local Nginx vhosts over public internet using Ngrok."""
+    if not shutil.which("ngrok"):
+        logger.error("ngrok is not installed or not in PATH.")
+        raise typer.Exit(code=1)
+        
+    vhosts = get_vhost_info()
+    if not vhosts:
+        logger.error("No vhosts found in /etc/nginx/sites-enabled.")
+        raise typer.Exit(code=1)
+        
+    console.print("\n[bold]Available VHosts[/bold]")
+    console.print("----------------")
+    for i, v in enumerate(vhosts):
+        ssl_tag = " (HTTPS)" if v["ssl"] else ""
+        console.print(f" {i + 1}) {v['domain']}{ssl_tag}")
+        
+    console.print("")
+    choice = typer.prompt("Select vhost index", type=int)
+    if choice < 1 or choice > len(vhosts):
+        logger.error("Invalid selection.")
+        raise typer.Exit(code=1)
+        
+    selected = vhosts[choice - 1]
+    domain = selected["domain"]
+    is_ssl = selected["ssl"]
+    
+    policy_content = f'''on_http_request:
+  - actions:
+      - type: add-headers
+        config:
+          headers:
+            Host: "{domain}"
+
+on_http_response:
+  - expressions:
+      - 'res.status_code >= 300 && res.status_code < 400 && "location" in res.headers'
+      - 'res.headers["location"][0].contains("://{domain}")'
+    actions:
+      - type: add-headers
+        config:
+          headers:
+            Location: '${{res.headers["location"][0].replace("https://{domain}", conn.server_name.size() > 0 ? "https://" + conn.server_name : "").replace("http://{domain}", conn.server_name.size() > 0 ? "https://" + conn.server_name : "")}}'
+'''
+    
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as tmp:
+        tmp.write(policy_content)
+        policy_file = tmp.name
+        
+    logger.info(f"Selected domain: {domain}{' (HTTPS)' if is_ssl else ''}")
+    logger.info("Starting ngrok...")
+    target = "https://localhost:443" if is_ssl else "80"
+    cmd = ["ngrok", "http", target, "--traffic-policy-file", policy_file]
+    if is_ssl:
+        cmd.append("--upstream-tls-verify=false")
+    try:
+        subprocess.run(cmd)
+    finally:
+        Path(policy_file).unlink(missing_ok=True)

{ndev_stack-0.3.0 → ndev_stack-0.3.2}/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)
@@ -1876,7 +1877,7 @@ def redis_cli(port: int):
 
 @main.command(name="grok")
 @click.option("--domain", default=None, help="Vhost domain to tunnel. Omit to select interactively.")
-@click.option("--ssl", is_flag=True, help="Tunnel HTTPS port 443")
+@click.option("--ssl/--no-ssl", default=None, help="Tunnel HTTPS port 443 (defaults to auto-detecting vhost SSL)")
 def grok(domain, ssl):
     """Tunnel a local virtual host to the public web via ngrok."""
     if not domain:
@@ -1896,12 +1897,19 @@ def grok(domain, ssl):
             raise click.ClickException("Invalid selection.")
 
     domain = re.sub(r"^https?://", "", domain.strip().lower()).rstrip("/")
-    console.print(f"Starting ngrok tunnel for [bold cyan]{domain}[/bold cyan]{' (HTTPS)' if ssl else ''} -- Ctrl+C to stop.")
-    proc = grok_core.start_tunnel(domain, ssl=ssl)
+    v_meta = vhost_core.get_vhost(domain)
+    is_ssl = ssl if ssl is not None else bool(v_meta and v_meta.get("ssl"))
+    console.print(f"Starting ngrok tunnel for [bold cyan]{domain}[/bold cyan]{' (HTTPS)' if is_ssl else ''} -- Ctrl+C to stop.")
+    proc, policy_file = grok_core.start_tunnel(domain, ssl=ssl)
     try:
         proc.wait()
     except KeyboardInterrupt:
         proc.terminate()
+    finally:
+        try:
+            policy_file.unlink(missing_ok=True)
+        except Exception:
+            pass
 
 
 @main.command(name="tunnel", hidden=True)
@@ -1994,9 +2002,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 +2381,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.2}/ndev/win/core/fcgi.py

@@ -209,8 +209,12 @@ def nginx_upstream_name(version: str, domain: str | None = None) -> str:
 
 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)
+    if workers:
+        servers = "\n".join(f"    server 127.0.0.1:{w.port};" for w in workers)
+    else:
+        cfg = paths.load_config()
+        ports = ports_for(version, cfg["fcgi_workers_per_version"], cfg["fcgi_base_port"])
+        servers = "\n".join(f"    server 127.0.0.1:{p};" for p in ports)
     u_name = nginx_upstream_name(version, domain=domain)
     return f"upstream {u_name} {{\n{servers}\n}}\n"
+

ndev_stack-0.3.2/ndev/win/core/grok.py

@@ -0,0 +1,95 @@
+"""
+ngrok tunnel wrapper for ndev-win virtual hosts.
+"""
+from __future__ import annotations
+
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+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 | None = None) -> tuple[subprocess.Popen, Path]:
+    """
+    Start `ngrok http` against Nginx.
+    Rewrites the request Host header to `domain` and rewrites any response
+    redirect Location headers from the local domain back to the ngrok public URL.
+    Returns (Popen, policy_file_path).
+    """
+    import re
+    clean_domain = re.sub(r"^https?://", "", domain.strip().lower()).rstrip("/")
+    vhost_meta = vhost.get_vhost(clean_domain)
+    known = list_vhosts()
+    if not vhost_meta and clean_domain not in known:
+        raise FileNotFoundError(
+            f"No vhost found for '{clean_domain}'. Known vhosts: {known or '(none)'}"
+        )
+
+    # Determine SSL mode: use explicit flag if provided, otherwise auto-detect from vhost config
+    is_ssl = ssl if ssl is not None else bool(vhost_meta and vhost_meta.get("ssl"))
+
+    target = f"https://localhost:{HTTPS_PORT}" if is_ssl else str(HTTP_PORT)
+
+    # Build traffic policy YAML to ensure:
+    # 1. Request Host header is rewritten to clean_domain so Nginx routes to the right vhost.
+    # 2. Response Location header rewriting prevents external devices from being redirected
+    #    to the unresolvable local domain (e.g. *.local).
+    policy_content = f'''on_http_request:
+  - actions:
+      - type: add-headers
+        config:
+          headers:
+            Host: "{clean_domain}"
+
+on_http_response:
+  - expressions:
+      - 'res.status_code >= 300 && res.status_code < 400 && "location" in res.headers'
+      - 'res.headers["location"][0].contains("://{clean_domain}")'
+    actions:
+      - type: add-headers
+        config:
+          headers:
+            Location: '${{res.headers["location"][0].replace("https://{clean_domain}", conn.server_name.size() > 0 ? "https://" + conn.server_name : "").replace("http://{clean_domain}", conn.server_name.size() > 0 ? "https://" + conn.server_name : "")}}'
+'''
+
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as tmp:
+        tmp.write(policy_content)
+        policy_file = Path(tmp.name)
+
+    cmd = [_ngrok_exe(), "http", target, "--traffic-policy-file", str(policy_file)]
+    if is_ssl:
+        cmd.append("--upstream-tls-verify=false")
+
+    proc = subprocess.Popen(cmd)
+    return proc, policy_file
+

{ndev_stack-0.3.0 → ndev_stack-0.3.2}/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.2}/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.2}/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 ----------------------------------------------------------