pulse-framework 0.1.38a2__tar.gz → 0.1.38a4__tar.gz

{pulse_framework-0.1.38a2 → pulse_framework-0.1.38a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pulse-framework
-Version: 0.1.38a2
+Version: 0.1.38a4
 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.38a2 → pulse_framework-0.1.38a4}/pyproject.toml

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

{pulse_framework-0.1.38a2 → pulse_framework-0.1.38a4}/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,
@@ -225,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(),
@@ -266,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 = [
-				"bun",
-				"run",
-				"start",
-				"--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
 	):
@@ -426,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(
@@ -471,26 +379,26 @@ class App:
 			)
 
 		# 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
+		# @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

{pulse_framework-0.1.38a2 → pulse_framework-0.1.38a4}/src/pulse/cli/cmd.py

@@ -34,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,
@@ -69,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"),
+	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)
@@ -106,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()}")
@@ -125,37 +139,54 @@ def run(
 			web_root if web_root.exists() else app_ctx.app_file
 		)
 
-	if not server_only:
-		# Skip dependency checking and installation in production/CI mode (assumes pre-built)
-		if env.pulse_env == "dev":
+	if env.pulse_env == "dev" and not server_only:
+		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 to_add:
 			try:
-				to_add = check_web_dependencies(
+				dep_plan = prepare_web_dependencies(
 					web_root,
 					pulse_version=PULSE_PY_VERSION,
 				)
-			except DependencyResolutionError as exc:
-				console.log(f"❌ {exc}")
+				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
-			except DependencyError as exc:
-				console.log(f"❌ {exc}")
-				raise typer.Exit(1) from None
-
-			if to_add:
-				try:
-					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
 
 	server_args = extra_flags if not web_only else []
 	web_args = extra_flags if web_only else []
 
 	commands: list[CommandSpec] = []
+	# Build web command first (when needed) so we can set PULSE_REACT_SERVER_ADDRESS
+	# before building the uvicorn command, which needs that env var
+	if not server_only:
+		if is_single_server:
+			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
+		else:
+			commands.append(build_web_command(web_root=web_root, extra_args=web_args))
+
 	if not web_only:
 		commands.append(
 			build_uvicorn_command(
@@ -169,12 +200,10 @@ def run(
 				console=console,
 				web_root=web_root,
 				announce_url=is_single_server,
+				verbose=verbose,
 			)
 		)
 
-	if 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"}
 
 	with FolderLock(web_root):
@@ -301,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] = [
@@ -338,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:
@@ -346,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
 
@@ -374,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.38a2 → pulse_framework-0.1.38a4}/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"
 
@@ -87,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.38a2 → pulse_framework-0.1.38a4}/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}"