pulse-framework 0.1.39__py3-none-any.whl → 0.1.41__py3-none-any.whl

pulse/cli/cmd.py

@@ -12,7 +12,7 @@ import subprocess
 import sys
 from collections.abc import Sequence
 from pathlib import Path
-from typing import cast
+from typing import Callable, cast
 
 import typer
 from rich.console import Console
@@ -110,14 +110,14 @@ def run(
 		port = find_available_port(port)
 
 	console = Console()
-	console.log(f"📁 Loading app from: {app_file}")
+	console.print(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
 
 	is_single_server = app_instance.mode == "single-server"
 	if is_single_server:
-		console.log("🔧 [cyan]Single-server mode[/cyan]")
+		console.print("🔧 [cyan]Single-server mode[/cyan]")
 
 	# In single-server + server-only mode, require explicit React server address
 	if is_single_server and server_only:
@@ -168,41 +168,76 @@ def run(
 	web_args = extra_flags if web_only else []
 
 	commands: list[CommandSpec] = []
+
+	# Track readiness for announcement
+	server_ready = {"server": False, "web": False}
+	announced = False
+
+	def mark_web_ready() -> None:
+		server_ready["web"] = True
+		check_and_announce()
+
+	def mark_server_ready() -> None:
+		server_ready["server"] = True
+		check_and_announce()
+
+	def check_and_announce() -> None:
+		"""Announce when all required servers are ready."""
+		nonlocal announced
+		if announced:
+			return
+
+		needs_server = not web_only
+		needs_web = not server_only
+
+		if needs_server and not server_ready["server"]:
+			return
+		if needs_web and not server_ready["web"]:
+			return
+
+		# All required servers are ready, show announcement
+		announced = True
+		protocol = "http" if address in ("127.0.0.1", "localhost") else "https"
+		server_url = f"{protocol}://{address}:{port}"
+		console.print("")
+		console.print(
+			f"✨ [bold green]Pulse running at:[/bold green] [bold cyan][link={server_url}]{server_url}[/link][/bold cyan]"
+		)
+		console.print(f"   [dim]API: {server_url}/_pulse/...[/dim]")
+		console.print("")
+
 	# 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))
+		web_port = find_available_port(5173)
+		web_cmd = build_web_command(
+			web_root=web_root,
+			extra_args=web_args,
+			port=web_port,
+			mode=app_instance.env,
+			ready_pattern=r"localhost:\d+",
+			on_ready=mark_web_ready,
+		)
+		commands.append(web_cmd)
+		# Set env var so app can read the React server address (only used in single-server mode)
+		env.react_server_address = f"http://localhost:{web_port}"
 
 	if not web_only:
-		commands.append(
-			build_uvicorn_command(
-				app_ctx=app_ctx,
-				address=address,
-				port=port,
-				reload_enabled=reload,
-				extra_args=server_args,
-				dev_secret=dev_secret,
-				server_only=server_only,
-				console=console,
-				web_root=web_root,
-				announce_url=is_single_server,
-				verbose=verbose,
-			)
+		server_cmd = build_uvicorn_command(
+			app_ctx=app_ctx,
+			address=address,
+			port=port,
+			reload_enabled=reload,
+			extra_args=server_args,
+			dev_secret=dev_secret,
+			server_only=server_only,
+			console=console,
+			web_root=web_root,
+			verbose=verbose,
+			ready_pattern=r"Application startup complete",
+			on_ready=mark_server_ready,
 		)
+		commands.append(server_cmd)
 
 	# Only add tags in dev mode to avoid breaking structured output (e.g., CloudWatch EMF metrics)
 	tag_colors = (
@@ -340,8 +375,9 @@ def build_uvicorn_command(
 	server_only: bool,
 	console: Console,
 	web_root: Path,
-	announce_url: bool,
 	verbose: bool = False,
+	ready_pattern: str | None = None,
+	on_ready: Callable[[], None] | None = None,
 ) -> CommandSpec:
 	app_import = f"{app_ctx.module_name}:{app_ctx.app_var}.asgi_factory"
 	args: list[str] = [
@@ -401,22 +437,13 @@ def build_uvicorn_command(
 		log_config_file.write_text(json.dumps(log_config))
 		args.extend(["--log-config", str(log_config_file)])
 
-	def _announce() -> None:
-		protocol = "http" if address in ("127.0.0.1", "localhost") else "https"
-		server_url = f"{protocol}://{address}:{port}"
-		console.log("")
-		console.log(
-			f"✨ [bold green]Pulse running at:[/bold green] [bold cyan][link={server_url}]{server_url}[/link][/bold cyan]"
-		)
-		console.log(f"   [dim]API: {server_url}/_pulse/...[/dim]")
-		console.log("")
-
 	return CommandSpec(
 		name="server",
 		args=args,
 		cwd=cwd,
 		env=command_env,
-		on_spawn=_announce if announce_url else None,
+		ready_pattern=ready_pattern,
+		on_ready=on_ready,
 	)
 
 
@@ -426,6 +453,8 @@ def build_web_command(
 	extra_args: Sequence[str],
 	port: int | None = None,
 	mode: PulseEnv = "dev",
+	ready_pattern: str | None = None,
+	on_ready: Callable[[], None] | None = None,
 ) -> CommandSpec:
 	command_env = os.environ.copy()
 	if mode == "prod":
@@ -453,7 +482,14 @@ def build_web_command(
 		}
 	)
 
-	return CommandSpec(name="web", args=args, cwd=web_root, env=command_env)
+	return CommandSpec(
+		name="web",
+		args=args,
+		cwd=web_root,
+		env=command_env,
+		ready_pattern=ready_pattern,
+		on_ready=on_ready,
+	)
 
 
 def _apply_app_context_to_env(app_ctx: AppLoadResult) -> None:

pulse/cli/models.py

@@ -31,3 +31,5 @@ class CommandSpec:
 	cwd: Path
 	env: dict[str, str]
 	on_spawn: Callable[[], None] | None = None
+	ready_pattern: str | None = None  # Regex pattern to detect when command is ready
+	on_ready: Callable[[], None] | None = None  # Callback when ready_pattern matches

pulse/cli/processes.py

@@ -3,25 +3,31 @@ from __future__ import annotations
 import contextlib
 import os
 import pty
+import re
 import select
 import signal
 import subprocess
 import sys
 from collections.abc import Mapping, Sequence
 from io import TextIOBase
-from typing import cast
+from typing import TypeVar, cast
 
 from rich.console import Console
 
 from pulse.cli.helpers import os_family
 from pulse.cli.models import CommandSpec
 
+_K = TypeVar("_K", int, str)
+
 ANSI_CODES = {
 	"cyan": "\033[36m",
 	"orange1": "\033[38;5;208m",
 	"default": "\033[90m",
 }
 
+# Regex to strip ANSI escape codes
+ANSI_ESCAPE = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+
 
 def execute_commands(
 	commands: Sequence[CommandSpec],
@@ -45,6 +51,34 @@ def execute_commands(
 	return _run_with_pty(commands, console=console, colors=color_lookup)
 
 
+def _call_on_spawn(spec: CommandSpec) -> None:
+	"""Call the on_spawn callback if it exists."""
+	if spec.on_spawn:
+		try:
+			spec.on_spawn()
+		except Exception:
+			pass
+
+
+def _check_on_ready(
+	spec: CommandSpec,
+	line: str,
+	ready_flags: dict[_K, bool],
+	key: _K,
+) -> None:
+	"""Check if line matches ready_pattern and call on_ready if needed."""
+	if spec.ready_pattern and not ready_flags[key]:
+		# Strip ANSI codes before matching
+		clean_line = ANSI_ESCAPE.sub("", line)
+		if re.search(spec.ready_pattern, clean_line):
+			ready_flags[key] = True
+			if spec.on_ready:
+				try:
+					spec.on_ready()
+				except Exception:
+					pass
+
+
 def _run_with_pty(
 	commands: Sequence[CommandSpec],
 	*,
@@ -52,8 +86,9 @@ def _run_with_pty(
 	colors: Mapping[str, str],
 ) -> int:
 	procs: list[tuple[str, int, int]] = []
-	fd_to_name: dict[int, str] = {}
+	fd_to_spec: dict[int, CommandSpec] = {}
 	buffers: dict[int, bytearray] = {}
+	ready_flags: dict[int, bool] = {}
 
 	try:
 		for spec in commands:
@@ -66,13 +101,10 @@ def _run_with_pty(
 				fcntl = __import__("fcntl")
 				fcntl.fcntl(fd, fcntl.F_SETFL, os.O_NONBLOCK)
 				procs.append((spec.name, pid, fd))
-				fd_to_name[fd] = spec.name
+				fd_to_spec[fd] = spec
 				buffers[fd] = bytearray()
-				if spec.on_spawn:
-					try:
-						spec.on_spawn()
-					except Exception:
-						pass
+				ready_flags[fd] = False
+				_call_on_spawn(spec)
 
 		while procs:
 			for tag, pid, fd in list(procs):
@@ -105,7 +137,9 @@ def _run_with_pty(
 						buffers[fd] = remainder
 						decoded = line.decode(errors="replace")
 						if decoded:
-							_write_tagged_line(fd_to_name[fd], decoded, colors)
+							spec = fd_to_spec[fd]
+							_write_tagged_line(spec.name, decoded, colors)
+							_check_on_ready(spec, decoded, ready_flags, fd)
 				except OSError:
 					continue
 
@@ -144,9 +178,10 @@ def _run_without_pty(
 ) -> int:
 	from selectors import EVENT_READ, DefaultSelector
 
-	procs: list[tuple[str, subprocess.Popen[str]]] = []
+	procs: list[tuple[str, subprocess.Popen[str], CommandSpec]] = []
 	completed_codes: list[int] = []
 	selector = DefaultSelector()
+	ready_flags: dict[str, bool] = {}
 
 	try:
 		for spec in commands:
@@ -160,14 +195,11 @@ def _run_without_pty(
 				bufsize=1,
 				universal_newlines=True,
 			)
-			if spec.on_spawn:
-				try:
-					spec.on_spawn()
-				except Exception:
-					pass
+			_call_on_spawn(spec)
 			if proc.stdout:
 				selector.register(proc.stdout, EVENT_READ, data=spec.name)
-			procs.append((spec.name, proc))
+			ready_flags[spec.name] = False
+			procs.append((spec.name, proc, spec))
 
 		while procs:
 			events = selector.select(timeout=0.1)
@@ -180,13 +212,16 @@ def _run_without_pty(
 				line = cast(TextIOBase, stream).readline()
 				if line:
 					_write_tagged_line(name, line.rstrip("\n"), colors)
+					spec = next((s for n, _, s in procs if n == name), None)
+					if spec:
+						_check_on_ready(spec, line, ready_flags, name)
 				else:
 					selector.unregister(stream)
-			remaining: list[tuple[str, subprocess.Popen[str]]] = []
-			for name, proc in procs:
+			remaining: list[tuple[str, subprocess.Popen[str], CommandSpec]] = []
+			for name, proc, spec in procs:
 				code = proc.poll()
 				if code is None:
-					remaining.append((name, proc))
+					remaining.append((name, proc, spec))
 				else:
 					completed_codes.append(code)
 					if proc.stdout:
@@ -195,12 +230,12 @@ def _run_without_pty(
 							proc.stdout.close()
 			procs = remaining
 	except KeyboardInterrupt:
-		for _name, proc in procs:
+		for _name, proc, _spec in procs:
 			with contextlib.suppress(Exception):
 				proc.terminate()
 		return 130
 	finally:
-		for _name, proc in procs:
+		for _name, proc, _spec in procs:
 			with contextlib.suppress(Exception):
 				proc.terminate()
 			with contextlib.suppress(Exception):
@@ -210,11 +245,21 @@ def _run_without_pty(
 				selector.unregister(key.fileobj)
 		selector.close()
 
-	exit_codes = completed_codes + [proc.returncode or 0 for _name, proc in procs]
+	exit_codes = completed_codes + [
+		proc.returncode or 0 for _name, proc, _spec in procs
+	]
 	return max(exit_codes) if exit_codes else 0
 
 
 def _write_tagged_line(name: str, message: str, colors: Mapping[str, str]) -> None:
+	# Filter out unwanted web server messages
+	clean_message = ANSI_ESCAPE.sub("", message)
+	if (
+		"Network: use --host to expose" in clean_message
+		or "press h + enter to show help" in clean_message
+	):
+		return
+
 	# Only add tags if colors dict is not empty (i.e., tagging is enabled)
 	if colors:
 		color = ANSI_CODES.get(colors.get(name, ""), ANSI_CODES["default"])

pulse/cli/uvicorn_log_config.py

@@ -54,7 +54,7 @@ def get_log_config(default_level: str = "info") -> dict[str, Any]:
 		"formatters": {
 			"default": {
 				"()": "uvicorn.logging.DefaultFormatter",
-				"fmt": "%(levelprefix)s %(message)s",
+				"fmt": "%(message)s",
 				"use_colors": None,
 			},
 			"access": {

pulse/codegen/codegen.py

@@ -3,6 +3,7 @@ import os
 from collections.abc import Sequence
 from dataclasses import dataclass
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from pulse.cli.helpers import ensure_gitignore_has
 from pulse.codegen.templates.layout import LAYOUT_TEMPLATE
@@ -16,6 +17,9 @@ from pulse.css import CssImport, CssModule
 from pulse.env import env
 from pulse.routing import Layout, Route, RouteTree
 
+if TYPE_CHECKING:
+	from pulse.app import ConnectionStatusConfig
+
 logger = logging.getLogger(__file__)
 
 
@@ -112,6 +116,7 @@ class Codegen:
 		server_address: str,
 		internal_server_address: str | None = None,
 		api_prefix: str = "",
+		connection_status: "ConnectionStatusConfig | None" = None,
 	):
 		# Ensure generated files are gitignored
 		ensure_gitignore_has(self.cfg.web_root, f"app/{self.cfg.pulse_dir}/")
@@ -124,7 +129,10 @@ class Codegen:
 		generated_files = set(
 			[
 				self.generate_layout_tsx(
-					server_address, internal_server_address, api_prefix
+					server_address,
+					internal_server_address,
+					api_prefix,
+					connection_status,
 				),
 				self.generate_routes_ts(),
 				self.generate_routes_runtime_ts(),
@@ -150,13 +158,18 @@ class Codegen:
 		server_address: str,
 		internal_server_address: str | None = None,
 		api_prefix: str = "",
+		connection_status: "ConnectionStatusConfig | None" = None,
 	):
 		"""Generates the content of _layout.tsx"""
+		from pulse.app import ConnectionStatusConfig
+
+		connection_status = connection_status or ConnectionStatusConfig()
 		content = str(
 			LAYOUT_TEMPLATE.render_unicode(
 				server_address=server_address,
 				internal_server_address=internal_server_address or server_address,
 				api_prefix=api_prefix,
+				connection_status=connection_status,
 			)
 		)
 		# The underscore avoids an eventual naming conflict with a generated

pulse/codegen/templates/layout.py

@@ -11,6 +11,11 @@ import { useLoaderData } from "react-router";
 export const config: PulseConfig = {
   serverAddress: "${server_address}",
   apiPrefix: "${api_prefix}",
+  connectionStatus: {
+    initialConnectingDelay: ${int(connection_status.initial_connecting_delay * 1000)},
+    initialErrorDelay: ${int(connection_status.initial_error_delay * 1000)},
+    reconnectErrorDelay: ${int(connection_status.reconnect_error_delay * 1000)},
+  },
 };
 
 
@@ -35,7 +40,10 @@ export async function loader(args: LoaderFunctionArgs) {
   if (!res.ok) throw new Error("Failed to prerender batch:" + res.status);
   const body = await res.json();
   if (body.redirect) return new Response(null, { status: 302, headers: { Location: body.redirect } });
-  if (body.notFound) return new Response(null, { status: 404 });
+  if (body.notFound) {
+    console.error("Not found:", url.pathname);
+    throw new Response("Not Found", { status: 404 });
+  }
   const prerenderData = deserialize(body) as PulsePrerender;
   const setCookies =
     (res.headers.getSetCookie?.() as string[] | undefined) ??
@@ -73,7 +81,7 @@ export async function clientLoader(args: ClientLoaderFunctionArgs) {
   if (!res.ok) throw new Error("Failed to prerender batch:" + res.status);
   const body = await res.json();
   if (body.redirect) return new Response(null, { status: 302, headers: { Location: body.redirect } });
-  if (body.notFound) return new Response(null, { status: 404 });
+  if (body.notFound) throw new Response("Not Found", { status: 404 });
   const prerenderData = deserialize(body) as PulsePrerender;
   if (typeof window !== "undefined" && typeof sessionStorage !== "undefined" && prerenderData.directives) {
     sessionStorage.setItem("__PULSE_DIRECTIVES", JSON.stringify(prerenderData.directives));