pulse-framework 0.1.38a1__tar.gz → 0.1.38a3__tar.gz

{pulse_framework-0.1.38a1 → pulse_framework-0.1.38a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pulse-framework
-Version: 0.1.38a1
+Version: 0.1.38a3
 Summary: Pulse - Full-stack framework for building real-time React applications in Python
 Requires-Dist: websockets>=12.0
 Requires-Dist: fastapi>=0.104.0

{pulse_framework-0.1.38a1 → pulse_framework-0.1.38a3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pulse-framework"
-version = "0.1.38a1"
+version = "0.1.38a3"
 description = "Pulse - Full-stack framework for building real-time React applications in Python"
 readme = "README.md"
 requires-python = ">=3.11"

{pulse_framework-0.1.38a1 → pulse_framework-0.1.38a3}/src/pulse/app.py

@@ -5,15 +5,12 @@ This module provides the main App class that users instantiate in their main.py
 to define routes and configure their Pulse application.
 """
 
-import asyncio
 import logging
 import os
-import subprocess
 from collections import defaultdict
 from collections.abc import Awaitable, Sequence
 from contextlib import asynccontextmanager
 from enum import IntEnum
-from pathlib import Path
 from typing import Any, Callable, Literal, NotRequired, TypedDict, TypeVar, cast
 
 import socketio
@@ -38,7 +35,11 @@ from pulse.css import (
 	registered_css_imports,
 	registered_css_modules,
 )
-from pulse.env import ENV_PULSE_HOST, ENV_PULSE_PORT, PulseEnv
+from pulse.env import (
+	ENV_PULSE_HOST,
+	ENV_PULSE_PORT,
+	PulseEnv,
+)
 from pulse.env import env as envvars
 from pulse.helpers import (
 	create_task,
@@ -165,7 +166,6 @@ class App:
 		internal_server_address: str | None = None,
 		not_found: str = "/not-found",
 		# Deployment and integration options
-		env: PulseEnv | None = None,
 		mode: PulseMode = "single-server",
 		api_prefix: str = "/_pulse",
 		cors: CORSOptions | None = None,
@@ -179,7 +179,7 @@ class App:
 		    codegen: Optional codegen configuration.
 		"""
 		# Resolve mode from environment and expose on the app instance
-		self.env = env or envvars.pulse_env
+		self.env = envvars.pulse_env
 		self.mode = mode
 		self.status = AppStatus.created
 		# Persist the server address for use by sessions (API calls, etc.)
@@ -226,10 +226,6 @@ class App:
 		# Map websocket sid -> renderId for message routing
 		self._socket_to_render = {}
 
-		# Subprocess management for single-server mode
-		self.web_server_proc: subprocess.Popen[str] | None = None
-		self.web_server_port: int | None = None
-
 		self.codegen = Codegen(
 			self.routes,
 			config=codegen or CodegenConfig(),
@@ -267,116 +263,26 @@ class App:
 		for plugin in self.plugins:
 			plugin.on_startup(self)
 
-		# Start React Router server in single-server mode
-		logger.info(f"Deployment mode: {self.mode}")
 		if self.mode == "single-server":
-			logger.info("Starting React Router server in single-server mode...")
-			try:
-				web_root = self.codegen.cfg.web_root
-				logger.info(f"Web root: {web_root}")
-				port = await self.start_web_server(web_root, self.env)
+			react_server_address = envvars.react_server_address
+			if react_server_address:
 				logger.info(
-					f"Single-server mode: React Router running on internal port {port}"
+					f"Single-server mode: React Router running at {react_server_address}"
+				)
+			else:
+				logger.warning(
+					"Single-server mode: PULSE_REACT_SERVER_ADDRESS not set."
 				)
-			except Exception:
-				logger.exception("Failed to start React Router server")
-				raise
 
 		try:
 			yield
 		finally:
-			# Stop React Router server in single-server mode
-			if self.mode == "single-server":
-				try:
-					self.stop_web_server()
-				except Exception:
-					logger.exception("Error stopping React Router server")
-
 			try:
 				if isinstance(self.session_store, SessionStore):
 					await self.session_store.close()
 			except Exception:
 				logger.exception("Error during SessionStore.close()")
 
-	async def start_web_server(self, web_root: Path, mode: str) -> int:
-		"""Start React Router server as subprocess and return its port."""
-
-		# Find available port
-		port = find_available_port(5173)
-
-		# Build command based on mode
-		if mode == "prod":
-			# Check if build exists
-			build_server = web_root / "build" / "server" / "index.js"
-			if not build_server.exists():
-				raise RuntimeError(
-					f"Production build not found at {build_server}. Run 'bun run build' in the web directory first."
-				)
-			cli_path = (
-				web_root
-				/ "node_modules"
-				/ "@react-router"
-				/ "serve"
-				/ "dist"
-				/ "cli.js"
-			)
-			if not cli_path.exists():
-				raise RuntimeError(
-					f"React Router CLI not found at {cli_path}. Did you install web dependencies?"
-				)
-			# Production: use Node to serve the built bundle (Bun lacks renderToPipeableStream)
-			cmd = [
-				"node",
-				str(cli_path),
-				"./build/server/index.js",
-				"--port",
-				str(port),
-			]
-		else:
-			# Development: use dev server
-			cmd = ["bun", "run", "dev", "--port", str(port)]
-
-		logger.info(f"Starting React Router server: {' '.join(cmd)}")
-
-		proc = subprocess.Popen(
-			cmd,
-			cwd=web_root,
-			stdout=subprocess.PIPE,
-			stderr=subprocess.STDOUT,
-			env=os.environ.copy(),
-			text=True,
-		)
-
-		# Wait for server to be ready
-		await asyncio.sleep(2.0 if mode == "prod" else 1.0)
-
-		# Check if process is still running
-		if proc.poll() is not None:
-			output = proc.stdout.read() if proc.stdout else ""
-			raise RuntimeError(f"React Router server failed to start: {output}")
-
-		self.web_server_proc = proc
-		self.web_server_port = port
-
-		logger.info(f"React Router server started on port {port}")
-		return port
-
-	def stop_web_server(self):
-		"""Stop the React Router subprocess."""
-		if self.web_server_proc:
-			logger.info("Stopping React Router server...")
-			self.web_server_proc.terminate()
-			try:
-				self.web_server_proc.wait(timeout=5)
-			except subprocess.TimeoutExpired:
-				logger.warning(
-					"React Router server did not stop gracefully, killing..."
-				)
-				self.web_server_proc.kill()
-				self.web_server_proc.wait()
-			self.web_server_proc = None
-			self.web_server_port = None
-
 	def run_codegen(
 		self, address: str | None = None, internal_address: str | None = None
 	):
@@ -427,10 +333,11 @@ class App:
 		self.setup(server_address)
 		self.status = AppStatus.running
 
-		# Wrap with proxy in single-server mode. Do it here instead of within
-		# __init__ to allow the CLI to override the mode.
+		# In single-server mode, the Pulse server acts as reverse proxy to the React server
 		if self.mode == "single-server":
-			return PulseProxy(self.asgi, lambda: self.web_server_port, self.api_prefix)
+			return PulseProxy(
+				self.asgi, lambda: envvars.react_server_address, self.api_prefix
+			)
 		return self.asgi
 
 	def run(
@@ -464,11 +371,35 @@ class App:
 			self.fastapi.add_middleware(CORSMiddleware, **self.cors)
 		else:
 			# Use deployment-specific CORS settings
+			cors_config = cors_options(self.mode, self.server_address)
+			print(f"CORS config: {cors_config}")
 			self.fastapi.add_middleware(
 				CORSMiddleware,
-				**cors_options(self.mode, self.server_address),
+				**cors_config,
 			)
 
+		# Debug middleware to log CORS-related request details
+		# @self.fastapi.middleware("http")
+		# async def cors_debug_middleware(  # pyright: ignore[reportUnusedFunction]
+		# 	request: Request, call_next: Callable[[Request], Awaitable[Response]]
+		# ):
+		# 	origin = request.headers.get("origin")
+		# 	method = request.method
+		# 	path = request.url.path
+		# 	print(
+		# 		f"[CORS Debug] {method} {path} | Origin: {origin} | "
+		# 		+ f"Mode: {self.mode} | Server: {self.server_address}"
+		# 	)
+		# 	response = await call_next(request)
+		# 	allow_origin = response.headers.get("access-control-allow-origin")
+		# 	if allow_origin:
+		# 		print(f"[CORS Debug] Response allows origin: {allow_origin}")
+		# 	elif origin:
+		# 		logger.warning(
+		# 			f"[CORS Debug] Origin {origin} present but no Access-Control-Allow-Origin header set"
+		# 		)
+		# 	return response
+
 		# Mount PulseContext for all FastAPI routes (no route info). Other API
 		# routes / middleware should be added at the module-level, which means
 		# this middleware will wrap all of them.

{pulse_framework-0.1.38a1 → pulse_framework-0.1.38a3}/src/pulse/cli/cmd.py

@@ -21,6 +21,7 @@ from pulse.cli.dependencies import (
 	DependencyError,
 	DependencyPlan,
 	DependencyResolutionError,
+	check_web_dependencies,
 	prepare_web_dependencies,
 )
 from pulse.cli.folder_lock import FolderLock
@@ -33,6 +34,7 @@ from pulse.env import (
 	ENV_PULSE_DISABLE_CODEGEN,
 	ENV_PULSE_HOST,
 	ENV_PULSE_PORT,
+	ENV_PULSE_REACT_SERVER_ADDRESS,
 	ENV_PULSE_SECRET,
 	PulseEnv,
 	env,
@@ -68,8 +70,16 @@ def run(
 	prod: bool = typer.Option(False, "--prod", help="Run in production env"),
 	server_only: bool = typer.Option(False, "--server-only", "--backend-only"),
 	web_only: bool = typer.Option(False, "--web-only"),
-	reload: bool = typer.Option(True, "--reload/--no-reload"),
+	react_server_address: str | None = typer.Option(
+		None,
+		"--react-server-address",
+		help="Full URL of React server (required for single-server + --server-only)",
+	),
+	reload: bool | None = typer.Option(None, "--reload/--no-reload"),
 	find_port: bool = typer.Option(True, "--find-port/--no-find-port"),
+	verbose: bool = typer.Option(
+		False, "--verbose", help="Show all logs without filtering"
+	),
 ):
 	"""Run the Pulse server and web development server together."""
 	extra_flags = list(ctx.args)
@@ -88,6 +98,10 @@ def run(
 	if len(env_flags) == 1:
 		env.pulse_env = cast(PulseEnv, env_flags[0])
 
+	# Turn on reload in dev only
+	if reload is None:
+		reload = env.pulse_env == "dev"
+
 	if server_only and web_only:
 		typer.echo("❌ Cannot use --server-only and --web-only at the same time.")
 		raise typer.Exit(1)
@@ -101,14 +115,19 @@ def run(
 	_apply_app_context_to_env(app_ctx)
 	app_instance = app_ctx.app
 
-	# Override mode to subdomains if server-only (single-server + server-only makes no sense)
-	if server_only and app_instance.mode == "single-server":
-		app_instance.mode = "subdomains"
-
 	is_single_server = app_instance.mode == "single-server"
 	if is_single_server:
 		console.log("🔧 [cyan]Single-server mode[/cyan]")
 
+	# In single-server + server-only mode, require explicit React server address
+	if is_single_server and server_only:
+		if not react_server_address:
+			typer.echo(
+				"❌ --react-server-address is required when using single-server mode with --server-only."
+			)
+			raise typer.Exit(1)
+		os.environ[ENV_PULSE_REACT_SERVER_ADDRESS] = react_server_address
+
 	web_root = app_instance.codegen.cfg.web_root
 	if not web_root.exists() and not server_only:
 		console.log(f"❌ Directory not found: {web_root.absolute()}")
@@ -121,10 +140,10 @@ def run(
 		)
 
 	if not server_only:
-		# Skip dependency installation in production mode (assumes pre-built)
-		if app_instance.env != "prod":
+		# Skip dependency checking and installation in production/CI mode (assumes pre-built)
+		if env.pulse_env == "dev":
 			try:
-				dep_plan = prepare_web_dependencies(
+				to_add = check_web_dependencies(
 					web_root,
 					pulse_version=PULSE_PY_VERSION,
 				)
@@ -135,9 +154,14 @@ def run(
 				console.log(f"❌ {exc}")
 				raise typer.Exit(1) from None
 
-			if dep_plan:
+			if to_add:
 				try:
-					_run_dependency_plan(console, web_root, dep_plan)
+					dep_plan = prepare_web_dependencies(
+						web_root,
+						pulse_version=PULSE_PY_VERSION,
+					)
+					if dep_plan:
+						_run_dependency_plan(console, web_root, dep_plan)
 				except subprocess.CalledProcessError:
 					console.log("❌ Failed to install web dependencies with Bun.")
 					raise typer.Exit(1) from None
@@ -159,10 +183,25 @@ def run(
 				console=console,
 				web_root=web_root,
 				announce_url=is_single_server,
+				verbose=verbose,
 			)
 		)
 
-	if not is_single_server and not server_only:
+	# In single-server mode, start web server separately (not managed by app lifecycle)
+	if is_single_server and not server_only:
+		web_port = find_available_port(5173)
+		commands.append(
+			build_web_command(
+				web_root=web_root,
+				extra_args=web_args,
+				port=web_port,
+				mode=app_instance.env,
+			)
+		)
+		# Set env var so app can read the React server address
+		react_server_address = f"http://localhost:{web_port}"
+		os.environ[ENV_PULSE_REACT_SERVER_ADDRESS] = react_server_address
+	elif not is_single_server and not server_only:
 		commands.append(build_web_command(web_root=web_root, extra_args=web_args))
 
 	tag_colors = {"server": "cyan", "web": "orange1"}
@@ -219,6 +258,66 @@ def generate(
 		console.log("⚠️  No routes found to generate")
 
 
+@cli.command("check")
+def check(
+	app_file: str = typer.Argument(
+		..., help="App target: 'path.py[:var]' (default :app) or 'module:var'"
+	),
+	fix: bool = typer.Option(
+		False, "--fix", help="Install missing or outdated dependencies"
+	),
+):
+	"""Check if web project dependencies are in sync with Pulse app requirements."""
+	console = Console()
+
+	console.log(f"📁 Loading app from: {app_file}")
+	app_ctx = load_app_from_target(app_file)
+	_apply_app_context_to_env(app_ctx)
+	app_instance = app_ctx.app
+
+	web_root = app_instance.codegen.cfg.web_root
+	if not web_root.exists():
+		console.log(f"❌ Directory not found: {web_root.absolute()}")
+		raise typer.Exit(1)
+
+	try:
+		to_add = check_web_dependencies(
+			web_root,
+			pulse_version=PULSE_PY_VERSION,
+		)
+	except DependencyResolutionError as exc:
+		console.log(f"❌ {exc}")
+		raise typer.Exit(1) from None
+	except DependencyError as exc:
+		console.log(f"❌ {exc}")
+		raise typer.Exit(1) from None
+
+	if not to_add:
+		console.log("✅ Web dependencies are in sync")
+		return
+
+	console.log("📦 Web dependencies are out of sync:")
+	for pkg in to_add:
+		console.log(f"  - {pkg}")
+
+	if not fix:
+		console.log("💡 Run 'pulse check --fix' to install missing dependencies")
+		return
+
+	# Apply fix
+	try:
+		dep_plan = prepare_web_dependencies(
+			web_root,
+			pulse_version=PULSE_PY_VERSION,
+		)
+		if dep_plan:
+			_run_dependency_plan(console, web_root, dep_plan)
+		console.log("✅ Web dependencies synced successfully")
+	except subprocess.CalledProcessError:
+		console.log("❌ Failed to install web dependencies with Bun.")
+		raise typer.Exit(1) from None
+
+
 def build_uvicorn_command(
 	*,
 	app_ctx: AppLoadResult,
@@ -231,6 +330,7 @@ def build_uvicorn_command(
 	console: Console,
 	web_root: Path,
 	announce_url: bool,
+	verbose: bool = False,
 ) -> CommandSpec:
 	app_import = f"{app_ctx.module_name}:{app_ctx.app_var}.asgi_factory"
 	args: list[str] = [
@@ -245,7 +345,7 @@ def build_uvicorn_command(
 		"--factory",
 	]
 
-	if reload_enabled and app_ctx.app.env != "prod":
+	if reload_enabled:
 		args.append("--reload")
 		args.extend(["--reload-include", "*.css"])
 		app_dir = app_ctx.app_dir or Path.cwd()
@@ -268,6 +368,11 @@ def build_uvicorn_command(
 			ENV_PULSE_PORT: str(port),
 		}
 	)
+	# Pass React server address to uvicorn process if set
+	if ENV_PULSE_REACT_SERVER_ADDRESS in os.environ:
+		command_env[ENV_PULSE_REACT_SERVER_ADDRESS] = os.environ[
+			ENV_PULSE_REACT_SERVER_ADDRESS
+		]
 	if app_ctx.app.env == "prod" and server_only:
 		command_env[ENV_PULSE_DISABLE_CODEGEN] = "1"
 	if dev_secret:
@@ -276,7 +381,7 @@ def build_uvicorn_command(
 	cwd = app_ctx.server_cwd or app_ctx.app_dir or Path.cwd()
 
 	# Apply custom log config to filter noisy requests (dev/ci only)
-	if app_ctx.app.env != "prod":
+	if app_ctx.app.env != "prod" and not verbose:
 		import json
 		import tempfile
 
@@ -304,8 +409,21 @@ def build_uvicorn_command(
 	)
 
 
-def build_web_command(*, web_root: Path, extra_args: Sequence[str]) -> CommandSpec:
-	args = ["bun", "run", "dev"]
+def build_web_command(
+	*,
+	web_root: Path,
+	extra_args: Sequence[str],
+	port: int | None = None,
+	mode: PulseEnv = "dev",
+) -> CommandSpec:
+	if mode == "prod":
+		# Production: use built server
+		args = ["bun", "run", "start"]
+	else:
+		# Development: use dev server
+		args = ["bun", "run", "dev"]
+	if port is not None:
+		args.extend(["--port", str(port)])
 	if extra_args:
 		args.extend(extra_args)
 

{pulse_framework-0.1.38a1 → pulse_framework-0.1.38a3}/src/pulse/cli/dependencies.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import re
 from collections.abc import Callable, Iterable, Sequence
 from dataclasses import dataclass
 from pathlib import Path
@@ -18,6 +19,53 @@ from pulse.cli.packages import (
 from pulse.react_component import ReactComponent, registered_react_components
 
 
+def convert_pep440_to_semver(python_version: str) -> str:
+	"""Convert PEP 440 version format to NPM semver format.
+
+	PEP 440 formats:
+	- 0.1.37a1 -> 0.1.37-alpha.1
+	- 0.1.37b1 -> 0.1.37-beta.1
+	- 0.1.37rc1 -> 0.1.37-rc.1
+	- 0.1.37.dev1 -> 0.1.37-dev.1
+
+	Non-pre-release versions are returned unchanged.
+	"""
+	# Match pre-release patterns: version followed by a/b/rc/dev + number
+	# PEP 440: a1, b1, rc1, dev1, alpha1, beta1, etc.
+	pattern = r"^(\d+\.\d+\.\d+)([a-z]+)(\d+)$"
+	match = re.match(pattern, python_version)
+
+	if match:
+		base_version = match.group(1)
+		prerelease_type = match.group(2)
+		prerelease_num = match.group(3)
+
+		# Map PEP 440 prerelease types to NPM semver
+		type_map = {
+			"a": "alpha",
+			"alpha": "alpha",
+			"b": "beta",
+			"beta": "beta",
+			"rc": "rc",
+			"c": "rc",  # PEP 440 also allows 'c' for release candidate
+			"dev": "dev",
+		}
+
+		npm_type = type_map.get(prerelease_type.lower(), prerelease_type)
+		return f"{base_version}-{npm_type}.{prerelease_num}"
+
+	# Also handle .dev format (e.g., 0.1.37.dev1)
+	pattern2 = r"^(\d+\.\d+\.\d+)\.dev(\d+)$"
+	match2 = re.match(pattern2, python_version)
+	if match2:
+		base_version = match2.group(1)
+		dev_num = match2.group(2)
+		return f"{base_version}-dev.{dev_num}"
+
+	# No pre-release, return as-is
+	return python_version
+
+
 class DependencyError(RuntimeError):
 	"""Base error for dependency preparation failures."""
 
@@ -38,15 +86,15 @@ class DependencyPlan:
 	to_add: Sequence[str]
 
 
-def prepare_web_dependencies(
+def get_required_dependencies(
 	web_root: Path,
 	*,
 	pulse_version: str,
 	component_provider: Callable[
 		[], Iterable[ReactComponent[Any]]
 	] = registered_react_components,
-) -> DependencyPlan | None:
-	"""Inspect registered components and return the Bun command needed to sync dependencies."""
+) -> dict[str, str | None]:
+	"""Get the required dependencies for a Pulse app."""
 	if not web_root.exists():
 		raise DependencyError(f"Directory not found: {web_root}")
 
@@ -102,13 +150,30 @@ def prepare_web_dependencies(
 	]:
 		desired.setdefault(pkg, "^7")
 
+	return desired
+
+
+def check_web_dependencies(
+	web_root: Path,
+	*,
+	pulse_version: str,
+	component_provider: Callable[
+		[], Iterable[ReactComponent[Any]]
+	] = registered_react_components,
+) -> list[str]:
+	"""Check if web dependencies are in sync and return list of packages that need to be added/updated."""
+	desired = get_required_dependencies(
+		web_root=web_root,
+		pulse_version=pulse_version,
+		component_provider=component_provider,
+	)
 	pkg_json = load_package_json(web_root)
 
 	to_add: list[str] = []
 	for name, req_ver in sorted(desired.items()):
 		effective = req_ver
 		if name == "pulse-ui-client":
-			effective = pulse_version
+			effective = convert_pep440_to_semver(pulse_version)
 
 		existing = get_pkg_spec(pkg_json, name)
 		if existing is None:
@@ -123,6 +188,24 @@ def prepare_web_dependencies(
 
 		to_add.append(f"{name}@{effective}" if effective else name)
 
+	return to_add
+
+
+def prepare_web_dependencies(
+	web_root: Path,
+	*,
+	pulse_version: str,
+	component_provider: Callable[
+		[], Iterable[ReactComponent[Any]]
+	] = registered_react_components,
+) -> DependencyPlan | None:
+	"""Inspect registered components and return the Bun command needed to sync dependencies."""
+	to_add = check_web_dependencies(
+		web_root=web_root,
+		pulse_version=pulse_version,
+		component_provider=component_provider,
+	)
+
 	if to_add:
 		return DependencyPlan(command=["bun", "add", *to_add], to_add=to_add)
 

{pulse_framework-0.1.38a1 → pulse_framework-0.1.38a3}/src/pulse/cookies.py

@@ -155,10 +155,15 @@ def cors_options(mode: "PulseMode", server_address: str) -> CORSOptions:
 	}
 	if mode == "subdomains":
 		base = _base_domain(host)
+		# Escape dots in base domain for regex (doesn't affect localhost since it has no dots)
+		base = base.replace(".", r"\.")
+		# Allow any subdomain and any port for the base domain
 		opts["allow_origin_regex"] = rf"^https?://([a-z0-9-]+\\.)?{base}(:\\d+)?$"
 		return opts
 	elif mode == "single-server":
 		# For single-server mode, allow same origin
+		# Escape dots in host for regex (doesn't affect localhost since it has no dots)
+		host = host.replace(".", r"\.")
 		opts["allow_origin_regex"] = rf"^https?://{host}(:\\d+)?$"
 		return opts
 	else:

{pulse_framework-0.1.38a1 → pulse_framework-0.1.38a3}/src/pulse/env.py

@@ -25,6 +25,7 @@ ENV_PULSE_APP_FILE = "PULSE_APP_FILE"
 ENV_PULSE_APP_DIR = "PULSE_APP_DIR"
 ENV_PULSE_HOST = "PULSE_HOST"
 ENV_PULSE_PORT = "PULSE_PORT"
+ENV_PULSE_REACT_SERVER_ADDRESS = "PULSE_REACT_SERVER_ADDRESS"
 ENV_PULSE_SECRET = "PULSE_SECRET"
 ENV_PULSE_DISABLE_CODEGEN = "PULSE_DISABLE_CODEGEN"
 
@@ -39,13 +40,12 @@ class EnvVars:
 		else:
 			os.environ[key] = value
 
-	# Pulse mode
 	@property
 	def pulse_env(self) -> PulseEnv:
 		value = (self._get(ENV_PULSE_MODE) or "dev").lower()
 		if value not in ("dev", "ci", "prod"):
 			value = "dev"
-		return value  # type: ignore[return-value]
+		return value
 
 	@pulse_env.setter
 	def pulse_env(self, value: PulseEnv) -> None:
@@ -88,6 +88,14 @@ class EnvVars:
 	def pulse_port(self, value: int) -> None:
 		self._set(ENV_PULSE_PORT, str(value))
 
+	@property
+	def react_server_address(self) -> str | None:
+		return self._get(ENV_PULSE_REACT_SERVER_ADDRESS)
+
+	@react_server_address.setter
+	def react_server_address(self, value: str | None) -> None:
+		self._set(ENV_PULSE_REACT_SERVER_ADDRESS, value)
+
 	# Secrets
 	@property
 	def pulse_secret(self) -> str | None:

{pulse_framework-0.1.38a1 → pulse_framework-0.1.38a3}/src/pulse/proxy.py

@@ -24,7 +24,7 @@ class PulseProxy:
 	def __init__(
 		self,
 		app: ASGIApp,
-		get_web_port: Callable[[], int | None],
+		get_react_server_address: Callable[[], str | None],
 		api_prefix: str = "/_pulse",
 	):
 		"""
@@ -32,11 +32,13 @@ class PulseProxy:
 
 		Args:
 		    app: The ASGI application to wrap (socketio.ASGIApp)
-		    get_web_port: Callable that returns the React Router port (or None if not started)
+		    get_react_server_address: Callable that returns the React Router server full URL (or None if not started)
 		    api_prefix: Prefix for API routes that should NOT be proxied (default: "/_pulse")
 		"""
 		self.app: ASGIApp = app
-		self.get_web_port: Callable[[], int | None] = get_web_port
+		self.get_react_server_address: Callable[[], str | None] = (
+			get_react_server_address
+		)
 		self.api_prefix: str = api_prefix
 		self._client: httpx.AsyncClient | None = None
 
@@ -84,10 +86,10 @@ class PulseProxy:
 		"""
 		Forward HTTP request to React Router server and stream response back.
 		"""
-		# Get the web server port
-		port = self.get_web_port()
-		if port is None:
-			# Web server not started yet, return error
+		# Get the React server address
+		react_server_address = self.get_react_server_address()
+		if react_server_address is None:
+			# React server not started yet, return error
 			await send(
 				{
 					"type": "http.response.start",
@@ -98,7 +100,7 @@ class PulseProxy:
 			await send(
 				{
 					"type": "http.response.body",
-					"body": b"Service Unavailable: Web server not ready",
+					"body": b"Service Unavailable: React server not ready",
 				}
 			)
 			return
@@ -106,8 +108,9 @@ class PulseProxy:
 		# Build target URL
 		path = scope["path"]
 		query_string = scope.get("query_string", b"").decode("utf-8")
-		target_url = f"http://localhost:{port}"
-		target_path = f"{target_url}{path}"
+		# Ensure react_server_address doesn't end with /
+		base_url = react_server_address.rstrip("/")
+		target_path = f"{base_url}{path}"
 		if query_string:
 			target_path += f"?{query_string}"