Make devserver backend health check endpoint configurable, preserved in upgrades and optional.

fastapi-vue/fastapi_vue/hostutil.py

@@ -12,6 +12,7 @@ def parse_endpoint(value: str | None, default_port: int = 0) -> list[dict]:
 
     Returns:
         List of dicts with uvicorn bind kwargs (host/port or uds).
+        Two entries may be returned for IPv4 and IPv6 (all interaces).
 
     Supported forms:
     - None or empty -> [{host: "localhost", port: default_port}]
@@ -65,3 +66,19 @@ def parse_endpoint(value: str | None, default_port: int = 0) -> list[dict]:
         ipaddress.ip_address(host)
 
     return [{"host": host, "port": port}]
+
+
+def parse_endpoints(
+    listen: str | list[str] | None = None, default_port: int = 8000
+) -> list[dict]:
+    """Parse listen strings into a list of endpoint dicts.
+
+    Args:
+        listen: Endpoint string(s) (see parse_endpoint for formats).
+        default_port: Port to use when not specified in listen args.
+    """
+    if listen is None:
+        listen = [f"localhost:{default_port}"]
+    elif isinstance(listen, str):
+        listen = [listen]
+    return [ep for s in listen for ep in parse_endpoint(s, default_port)]

fastapi-vue/fastapi_vue/server.py

@@ -6,7 +6,7 @@ from contextlib import suppress
 import uvicorn
 from uvicorn import Config, Server
 
-from .hostutil import parse_endpoint
+from .hostutil import parse_endpoints
 
 logger = logging.getLogger(__name__)
 
@@ -30,13 +30,9 @@ def run(
         workers: Number of worker processes (requires uvicorn.run, single endpoint only).
         **uvicorn_config: Additional uvicorn config options (overrides all other settings).
     """
-    if listen is None:
-        listen = [f"localhost:{default_port}"]
-    elif isinstance(listen, str):
-        listen = [listen]
-    endpoints: list[dict] = []
-    for ep in listen:
-        endpoints.extend(parse_endpoint(ep, default_port))
+    endpoints = parse_endpoints(listen, default_port)
+    if not endpoints:
+        raise ValueError("No endpoints to serve; check listen configuration")
 
     conf: dict[str, object] = {"app": app, "reload": reload, "workers": workers}
     proxy = os.getenv("FORWARDED_ALLOW_IPS", "127.0.0.1,::1")
@@ -45,7 +41,7 @@ def run(
         conf["forwarded_allow_ips"] = proxy
     conf.update(uvicorn_config)
 
-    with suppress(KeyboardInterrupt):
+    with suppress(KeyboardInterrupt, asyncio.CancelledError):
         if reload or workers:
             serve_multiprocess(endpoints, **conf)
         else:

fastapi_vue_setup.py

@@ -21,6 +21,7 @@ import subprocess
 import sys
 from pathlib import Path
 from textwrap import indent
+from typing import Literal
 
 import tomlkit
 
@@ -38,12 +39,16 @@ def print_boxed(text: str) -> None:
     print(f"╰{'─' * width}╯")
 
 
-def ruff_format_content(content: str, target_path: Path) -> str:
+def ruff_format_content(
+    content: str, target_path: Path, *, mode: Literal["isort", "full"] = "full"
+) -> str:
     """Format Python content using ruff with project settings.
 
-    Writes to a temp file (.new.py) next to target, runs ruff check (import sorting)
-    and ruff format on it, reads back the result, and cleans up.
+    Writes to a temp file next to target, runs ruff check (import sorting)
+    and optionally ruff format on it, reads back the result, and cleans up.
     Returns the formatted content, or original if ruff fails.
+
+    mode='isort' only sorts imports; mode='full' also formats.
     """
     temp_file = target_path.with_suffix(".new.py")
     try:
@@ -65,6 +70,8 @@ def ruff_format_content(content: str, target_path: Path) -> str:
             cwd=target_path.parent,
             capture_output=True,
         )
+        if mode == "isort":
+            return temp_file.read_text("UTF-8")
         # Then format
         result = subprocess.run(
             ["uv", "run", "--with", "ruff", "ruff", "format", str(temp_file)],
@@ -103,6 +110,9 @@ def uv_add_packages(
 # If vite == dev, dev is incremented by 100
 DEFAULT_PORTS = (3100, 3100, 3200)
 
+# Default health check path for devserver backend readiness check
+DEFAULT_HEALTH = "/api/health?from=devserver.py"
+
 # Marker comment indicating file can be auto-upgraded
 # Users should remove this line to prevent automatic updates
 UPGRADE_MARKER = "auto-upgrade@fastapi-vue-setup"
@@ -253,23 +263,20 @@ def find_import_insertion_line(source: str) -> int:
     return 2 if source.startswith("#!") else 1
 
 
-def extract_existing_ports(project_dir: Path) -> tuple[int, int, int] | None:
+def extract_existing_ports(
+    project_dir: Path, main: Path
+) -> tuple[int, int, int] | None:
     """Extract existing port configuration from project files.
 
     Returns (default, vite, dev) or None if not found.
     """
-    module_name = find_module_name(project_dir)
-    if not module_name:
-        return None
-
     default_port = None
     vite_port = None
     dev_port = None
 
-    # Try to extract DEFAULT_PORT from __main__.py
-    main_file = project_dir / module_name / "__main__.py"
-    if main_file.exists():
-        content = main_file.read_text("UTF-8")
+    # Try to extract DEFAULT_PORT from the CLI main module
+    if main.exists():
+        content = main.read_text("UTF-8")
         match = re.search(r"DEFAULT_PORT\s*=\s*(\d+)", content)
         if match:
             default_port = int(match.group(1))
@@ -296,6 +303,29 @@ def extract_existing_ports(project_dir: Path) -> tuple[int, int, int] | None:
     return None
 
 
+# Sentinel for "not found" in extract_existing_health
+_HEALTH_NOT_FOUND = object()
+
+
+def extract_existing_health(project_dir: Path) -> str | object:
+    """Extract existing health path configuration from devserver.py.
+
+    Returns:
+        - The path string (may be empty to disable)
+        - _HEALTH_NOT_FOUND sentinel if not found or file doesn't exist
+    """
+    devserver_file = project_dir / "scripts" / "devserver.py"
+    if not devserver_file.exists():
+        return _HEALTH_NOT_FOUND
+
+    content = devserver_file.read_text("UTF-8")
+    # Match HEALTH = "/path" or HEALTH = ""
+    match = re.search(r'^HEALTH\s*=\s*"([^"]*)"', content, re.MULTILINE)
+    if match:
+        return match.group(1)
+    return _HEALTH_NOT_FOUND
+
+
 def load_template(path: str) -> str:
     """Load a template file from the template directory."""
     return (TEMPLATE_DIR / path).read_text("UTF-8")
@@ -715,6 +745,8 @@ def patch_app_file(
         print(f"✅ Would patch {path}")
         return True
 
+    # Sort imports only (avoid full formatting of user code)
+    content = ruff_format_content(content, path, mode="isort")
     path.write_text(content, "UTF-8", newline="\n")
     print(f"✅ Patched {path}")
 
@@ -836,7 +868,7 @@ def patch_frontend_health_check(frontend_dir: Path, dry: bool = False) -> bool:
             target_file = app_vue
 
     if target_file is None:
-        print("ℹ️  No Vue file found to patch, skipping frontend health check")
+        print("ℹ️  No default App.vue found to patch, not adding /api/health check")
         return False
 
     original_content = target_file.read_text("UTF-8")
@@ -881,7 +913,7 @@ def patch_frontend_health_check(frontend_dir: Path, dry: bool = False) -> bool:
     else:
         # Minimal App.vue - only patch if it contains the default welcome message
         if "<h1>You did it!</h1>" not in content:
-            print(f"ℹ️  Skipping {target_file} (not a default Vue template)")
+            print(f"ℹ️  Skipping {target_file} (not a Vue demo app)")
             return False
         # Insert before the </p> tag
         template_end = content.find("</template>")
@@ -1284,13 +1316,28 @@ def cmd_setup(args: argparse.Namespace) -> int:
     else:
         print(f"📦 Module: {module_name}")
 
+    module_dir = project_dir / module_name
+    scripts_dir = project_dir / "scripts"
+    fastapi_vue_scripts = scripts_dir / "fastapi-vue"
+
+    # Check if project already has a CLI entrypoint in pyproject.toml
+    existing_cli_module = _find_existing_cli_module_path(project_dir, module_name)
+
+    # Determine main module path for DEVMODE import
+    main_module_path = existing_cli_module or f"{module_name}.__main__"
+    if existing_cli_module:
+        print(f"ℹ️  Using existing CLI: {existing_cli_module}")
+
+    # Resolve the CLI main module to a file path
+    main = project_dir / Path(*main_module_path.split(".")).with_suffix(".py")
+
     # Determine port configuration
     # Priority: --ports argument > existing project values > defaults
     if args.ports:
         default_port, vite_port, dev_port = parse_ports(args.ports)
         ports_note = "(--ports)"
     else:
-        existing_ports = extract_existing_ports(project_dir)
+        existing_ports = extract_existing_ports(project_dir, main)
         if existing_ports:
             default_port, vite_port, dev_port = existing_ports
             ports_note = "(kept for upgrade)"
@@ -1302,24 +1349,35 @@ def cmd_setup(args: argparse.Namespace) -> int:
         f"📡 Ports: default={default_port}, vite={vite_port}, dev={dev_port} {ports_note}"
     )
 
+    # Determine health path configuration
+    # Priority: --health argument > existing project value > default
+    if args.health is not None:
+        health = args.health
+        health_note = "(--health)" if health else "(disabled via --health)"
+    else:
+        existing_health = extract_existing_health(project_dir)
+        if existing_health is not _HEALTH_NOT_FOUND:
+            # Explicitly configured (path string, possibly empty to disable)
+            health = existing_health
+            health_note = "(kept for upgrade)"
+        else:
+            # Not found - use default
+            health = DEFAULT_HEALTH
+            health_note = "(--health to override)"
+
+    if health:
+        print(f"🏥 Health check: {health} {health_note}")
+    else:
+        print(f"🏥 Health check: disabled {health_note}")
+
     # Title for templates
     project_title = module_name.replace("_", " ").title()
 
-    module_dir = project_dir / module_name
-    scripts_dir = project_dir / "scripts"
-    fastapi_vue_scripts = scripts_dir / "fastapi-vue"
-
     # Find existing FastAPI app
     app_info = (
         find_fastapi_app(module_dir, project_dir) if module_dir.exists() else None
     )
 
-    # Check if project already has a CLI entrypoint in pyproject.toml
-    existing_cli_module = _find_existing_cli_module_path(project_dir, module_name)
-
-    # Determine main module path for DEVMODE import
-    main_module_path = existing_cli_module or f"{module_name}.__main__"
-
     # Template variables
     tpl_vars = {
         "MODULE_NAME": module_name,
@@ -1327,6 +1385,7 @@ def cmd_setup(args: argparse.Namespace) -> int:
         "TEMPLATE_DEFAULT_PORT": str(default_port),
         "TEMPLATE_VITE_PORT": str(vite_port),
         "TEMPLATE_DEV_PORT": str(dev_port),
+        "TEMPLATE_HEALTH": f'"{health}"',
         "ENVPREFIX": module_name.upper(),
         "PROJECT_CLI": module_name,
         "MAIN_MODULE": main_module_path,
@@ -1336,13 +1395,15 @@ def cmd_setup(args: argparse.Namespace) -> int:
         app_file, app_var = app_info
         print(f"📍 Found FastAPI app: {app_var} in {app_file.name}")
         tpl_vars["APP_VAR"] = app_var
-        tpl_vars["APP_MODULE"] = app_file.stem
+        # Dotted module path relative to project dir (e.g. "paskia.fastapi.mainapp")
+        app_module = ".".join(app_file.relative_to(project_dir).with_suffix("").parts)
+        tpl_vars["APP_MODULE"] = app_module
     else:
         print("📍 No existing FastAPI app found, will create new one")
         app_file = None
         app_var = "app"
         tpl_vars["APP_VAR"] = app_var
-        tpl_vars["APP_MODULE"] = "app"
+        tpl_vars["APP_MODULE"] = f"{module_name}.app"
 
     # Create directories
     if not dry:
@@ -1414,11 +1475,8 @@ def cmd_setup(args: argparse.Namespace) -> int:
     # === Handle __main__.py ===
     if existing_cli_module:
         # Existing CLI entrypoint - write .new.py beside the existing main module
-        main_module_parts = existing_cli_module.split(".")
-        main_module_file = project_dir / ("/".join(main_module_parts) + ".py")
-        main_fallback = main_module_file.with_suffix(".new.py")
+        main_fallback = main.with_suffix(".new.py")
     else:
-        main_module_file = None
         main_fallback = module_dir / "__main__.new.py"
 
     main_file = module_dir / "__main__.py"
@@ -1445,28 +1503,27 @@ def cmd_setup(args: argparse.Namespace) -> int:
     else:
         # Existing CLI entrypoint: write our template as .new.py beside the existing module
         # and also patch the existing module with DEVMODE if needed
-        print(f"ℹ️  Using existing CLI: {existing_cli_module}")
         _write_fallback_file(
-            main_module_file or main_file,
+            main,
             main_fallback,
             main_content,
             dry=dry,
             executable=False,
         )
-        if main_module_file and main_module_file.exists():
-            content = main_module_file.read_text("UTF-8")
+        if main.exists():
+            content = main.read_text("UTF-8")
             if "DEVMODE" not in content:
                 new_content = _add_devmode_to_main(content)
-                new_file = main_module_file.with_suffix(".new.py")
+                new_file = main.with_suffix(".new.py")
                 _write_fallback_file(
-                    main_module_file,
+                    main,
                     new_file,
                     new_content,
                     dry=dry,
                     executable=False,
                 )
-        elif main_module_file:
-            print(f"⚠️  Existing CLI main module {main_module_file} not found")
+        else:
+            print(f"⚠️  Existing CLI main module {main} not found")
 
     # === Update vite.config.js/ts ===
     frontend_dir = project_dir / "frontend"
@@ -1564,9 +1621,7 @@ def cmd_setup(args: argparse.Namespace) -> int:
     # Show merge note if any .new.py files were written
     if _new_files_written:
         print()
-        print(
-            "⚠️  Note: Some files could not be auto-upgraded because you customized them."
-        )
+        print("⚠️  Some files could not be auto-upgraded because you customized them.")
         print("   Please manually merge the following files:")
         for new_file, original_file in _new_files_written:
             try:
@@ -1628,6 +1683,11 @@ Examples:
         metavar="BACKEND,VITE,DEV",
         help="Port configuration as comma-separated values (default: 3100,3100,3200)",
     )
+    parser.add_argument(
+        "--health",
+        metavar="PATH",
+        help="Health check path for devserver (default: /api/health?from=devserver.py, '' to disable)",
+    )
     parser.add_argument(
         "--dry", "--dry-run", action="store_true", help="Show what would be done"
     )

template/backend/__main__.py

@@ -17,12 +17,12 @@ def main():
         help=(f"Endpoint (default: localhost:{DEFAULT_PORT})."),
     )
     args = parser.parse_args()
-    dev = {"reload": True, "reload_dirs": ["MODULE_NAME"]}
+    dev = {"reload": True, "reload_dirs": ["paskia"]} if DEVMODE else {}
     server.run(
-        "MODULE_NAME.APP_MODULE:APP_VAR",
+        "APP_MODULE:APP_VAR",
         listen=args.listen,
         default_port=DEFAULT_PORT,
-        **(dev if DEVMODE else {}),
+        **dev,
     )
 
 

template/scripts/devserver.py

@@ -22,6 +22,7 @@ from devutil import (  # type: ignore
 
 DEFAULT_VITE_PORT = TEMPLATE_VITE_PORT
 DEFAULT_DEV_PORT = TEMPLATE_DEV_PORT
+HEALTH = TEMPLATE_HEALTH
 
 
 async def run_devserver(
@@ -45,7 +46,7 @@ async def run_devserver(
         npm_i = await pg.spawn(*npm_install, cwd=front)
         await check_ports_free(viteurl, backurl)
         await pg.spawn(*MODULE_NAME, *(extra_args or []))
-        await pg.wait(npm_i, ready(backurl, path="/api/health?from=devserver.py"))
+        await pg.wait(npm_i, ready(backurl, path=HEALTH))
         await pg.spawn(*vite, cwd=front)
 
 
@@ -58,12 +59,12 @@ def main():
     parser.add_argument(
         "-l",
         "--listen",
-        metavar="host:port",
+        metavar="addr",
         help=f"Vite (default: localhost:{DEFAULT_VITE_PORT})",
     )
     parser.add_argument(
         "--backend",
-        metavar="host:port",
+        metavar="addr",
         help=f"FastAPI (default: localhost:{DEFAULT_DEV_PORT})",
     )
     args, extra_args = parser.parse_known_args()
@@ -72,7 +73,7 @@ def main():
 
 
 HELP_EPILOG = """
-  scripts/devserver.py [args to PROJECT_CLI]
+  Other options are forwarded to PROJECT_CLI [args]
 
   JS_RUNTIME environment variable can be used to select the JS runtime:
   npm, deno, bun, or full path to the runtime executable (node maps to npm).

template/scripts/fastapi-vue/devutil.py

@@ -111,18 +111,19 @@ async def check_ports_free(*urls: str) -> None:
         await asyncio.gather(*[check(client, url) for url in urls])
 
 
-async def ready(url: str, path: str = "") -> None:
+async def ready(url: str, path: str = "", max_attempts=50) -> None:
     """Wait for the server to be ready by polling an endpoint.
 
+    Use empty path to disable the check and make this return immediately.
     Raises SystemExit(1) if server doesn't start in time.
     """
-    max_attempts = 50
-    full_url = f"{url}{path}"
+    if not path:
+        return
 
     async with httpx.AsyncClient() as client:
         for attempt in range(max_attempts):
             try:
-                await client.get(full_url, timeout=1.0)
+                await client.get(f"{url}{path}", timeout=1.0)
                 logger.info("✓ Backend ready!")
                 return
             except httpx.RequestError: