pulse-framework 0.1.37__py3-none-any.whl → 0.1.38a2__py3-none-any.whl

pulse/cli/processes.py

@@ -0,0 +1,225 @@
+from __future__ import annotations
+
+import contextlib
+import os
+import pty
+import select
+import signal
+import subprocess
+import sys
+from collections.abc import Mapping, Sequence
+from io import TextIOBase
+from typing import cast
+
+from rich.console import Console
+
+from pulse.cli.helpers import os_family
+from pulse.cli.models import CommandSpec
+
+ANSI_CODES = {
+	"cyan": "\033[36m",
+	"orange1": "\033[38;5;208m",
+	"default": "\033[90m",
+}
+
+
+def execute_commands(
+	commands: Sequence[CommandSpec],
+	*,
+	console: Console,
+	tag_colors: Mapping[str, str] | None = None,
+) -> int:
+	"""Run the provided commands, streaming tagged output to stdout."""
+	if not commands:
+		return 0
+
+	color_lookup = dict(tag_colors or {})
+
+	# Avoid pty.fork() in multi-threaded environments (like pytest) to prevent
+	# "DeprecationWarning: This process is multi-threaded, use of forkpty() may lead to deadlocks"
+	# Also skip pty on Windows or if fork is unavailable
+	in_pytest = "pytest" in sys.modules
+	if os_family() == "windows" or not hasattr(pty, "fork") or in_pytest:
+		return _run_without_pty(commands, console=console, colors=color_lookup)
+
+	return _run_with_pty(commands, console=console, colors=color_lookup)
+
+
+def _run_with_pty(
+	commands: Sequence[CommandSpec],
+	*,
+	console: Console,
+	colors: Mapping[str, str],
+) -> int:
+	procs: list[tuple[str, int, int]] = []
+	fd_to_name: dict[int, str] = {}
+	buffers: dict[int, bytearray] = {}
+
+	try:
+		for spec in commands:
+			pid, fd = pty.fork()
+			if pid == 0:
+				if spec.cwd:
+					os.chdir(spec.cwd)
+				os.execvpe(spec.args[0], spec.args, spec.env)
+			else:
+				fcntl = __import__("fcntl")
+				fcntl.fcntl(fd, fcntl.F_SETFL, os.O_NONBLOCK)
+				procs.append((spec.name, pid, fd))
+				fd_to_name[fd] = spec.name
+				buffers[fd] = bytearray()
+				if spec.on_spawn:
+					try:
+						spec.on_spawn()
+					except Exception:
+						pass
+
+		while procs:
+			for tag, pid, fd in list(procs):
+				try:
+					wpid, status = os.waitpid(pid, os.WNOHANG)
+					if wpid == pid:
+						procs.remove((tag, pid, fd))
+						_close_fd(fd)
+				except ChildProcessError:
+					procs.remove((tag, pid, fd))
+					_close_fd(fd)
+
+			if not procs:
+				break
+
+			readable = [fd for _, _, fd in procs]
+			try:
+				ready, _, _ = select.select(readable, [], [], 0.1)
+			except (OSError, ValueError):
+				break
+
+			for fd in ready:
+				try:
+					data = os.read(fd, 4096)
+					if not data:
+						continue
+					buffers[fd].extend(data)
+					while b"\n" in buffers[fd]:
+						line, remainder = buffers[fd].split(b"\n", 1)
+						buffers[fd] = remainder
+						decoded = line.decode(errors="replace")
+						if decoded:
+							_write_tagged_line(fd_to_name[fd], decoded, colors)
+				except OSError:
+					continue
+
+		exit_codes: list[int] = []
+		for _tag, pid, fd in procs:
+			try:
+				_, status = os.waitpid(pid, 0)
+				exit_codes.append(os.WEXITSTATUS(status) if os.WIFEXITED(status) else 1)
+			except Exception:
+				pass
+			_close_fd(fd)
+
+		return max(exit_codes) if exit_codes else 0
+
+	except KeyboardInterrupt:
+		for _tag, pid, _fd in procs:
+			try:
+				os.kill(pid, signal.SIGTERM)
+			except Exception:
+				pass
+		return 130
+	finally:
+		for _tag, pid, fd in procs:
+			try:
+				os.kill(pid, signal.SIGKILL)
+			except Exception:
+				pass
+			_close_fd(fd)
+
+
+def _run_without_pty(
+	commands: Sequence[CommandSpec],
+	*,
+	console: Console,
+	colors: Mapping[str, str],
+) -> int:
+	from selectors import EVENT_READ, DefaultSelector
+
+	procs: list[tuple[str, subprocess.Popen[str]]] = []
+	completed_codes: list[int] = []
+	selector = DefaultSelector()
+
+	try:
+		for spec in commands:
+			proc = subprocess.Popen(
+				spec.args,
+				cwd=spec.cwd,
+				env=spec.env,
+				stdout=subprocess.PIPE,
+				stderr=subprocess.STDOUT,
+				text=True,
+				bufsize=1,
+				universal_newlines=True,
+			)
+			if spec.on_spawn:
+				try:
+					spec.on_spawn()
+				except Exception:
+					pass
+			if proc.stdout:
+				selector.register(proc.stdout, EVENT_READ, data=spec.name)
+			procs.append((spec.name, proc))
+
+		while procs:
+			events = selector.select(timeout=0.1)
+			for key, _mask in events:
+				name = key.data
+				stream = key.fileobj
+				if isinstance(stream, int):
+					continue
+				# stream is now guaranteed to be a file-like object
+				line = cast(TextIOBase, stream).readline()
+				if line:
+					_write_tagged_line(name, line.rstrip("\n"), colors)
+				else:
+					selector.unregister(stream)
+			remaining: list[tuple[str, subprocess.Popen[str]]] = []
+			for name, proc in procs:
+				code = proc.poll()
+				if code is None:
+					remaining.append((name, proc))
+				else:
+					completed_codes.append(code)
+					if proc.stdout:
+						with contextlib.suppress(Exception):
+							selector.unregister(proc.stdout)
+							proc.stdout.close()
+			procs = remaining
+	except KeyboardInterrupt:
+		for _name, proc in procs:
+			with contextlib.suppress(Exception):
+				proc.terminate()
+		return 130
+	finally:
+		for _name, proc in procs:
+			with contextlib.suppress(Exception):
+				proc.terminate()
+			with contextlib.suppress(Exception):
+				proc.wait(timeout=1)
+		for key in list(selector.get_map().values()):
+			with contextlib.suppress(Exception):
+				selector.unregister(key.fileobj)
+		selector.close()
+
+	exit_codes = completed_codes + [proc.returncode or 0 for _name, proc in procs]
+	return max(exit_codes) if exit_codes else 0
+
+
+def _write_tagged_line(name: str, message: str, colors: Mapping[str, str]) -> None:
+	color = ANSI_CODES.get(colors.get(name, ""), ANSI_CODES["default"])
+	sys.stdout.write(f"{color}[{name}]\033[0m {message}\n")
+	sys.stdout.flush()
+
+
+def _close_fd(fd: int) -> None:
+	with contextlib.suppress(Exception):
+		os.close(fd)

pulse/cli/secrets.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import secrets
+from pathlib import Path
+
+from pulse.cli.helpers import ensure_gitignore_has
+
+
+def resolve_dev_secret(app_path: Path | None) -> str | None:
+	"""Return or create a persisted development secret for the given app path."""
+	if app_path is None:
+		return None
+
+	try:
+		root = app_path if app_path.is_dir() else app_path.parent
+		secret_dir = root / ".pulse"
+		secret_dir.mkdir(parents=True, exist_ok=True)
+
+		secret_file = secret_dir / "secret"
+		if secret_file.exists():
+			try:
+				content = secret_file.read_text().strip()
+				if content:
+					return content
+			except Exception:
+				return None
+
+		secret_value = secrets.token_urlsafe(32)
+		try:
+			secret_file.write_text(secret_value)
+		except Exception:
+			# Best effort; secret still returned for current session
+			pass
+
+		ensure_gitignore_has(root, ".pulse/")
+
+		return secret_value
+	except Exception:
+		return None

pulse/cli/uvicorn_log_config.py

@@ -0,0 +1,87 @@
+"""Custom logging configuration for uvicorn to filter noisy requests."""
+
+import logging
+from typing import Any, override
+
+
+class FilterNoisyRequests(logging.Filter):
+	"""Filter out noisy requests from uvicorn access logs."""
+
+	# Patterns to suppress (static assets, node_modules, vite internals)
+	SUPPRESS_PATTERNS: tuple[str, ...] = (
+		"/node_modules/",
+		"/@vite/",
+		"/%40vite/",  # URL-encoded @vite
+		"/@fs/",
+		"/%40fs/",  # URL-encoded @fs
+		"/@id/",
+		"/%40id/",  # URL-encoded @id
+		"/@react-refresh",
+		"/app/",  # React Router source files served by Vite
+		".js?v=",
+		".css?v=",
+		".css ",  # CSS files (space indicates end of path in log)
+		".tsx ",  # TSX source files
+		".ts ",  # TS source files
+		".js ",  # JS files
+		".map",
+		"/favicon.ico",
+		"/.well-known/",  # Browser/DevTools well-known endpoints
+		"connection open",
+		"connection closed",
+		"connection rejected",
+		"304 Not Modified",  # Usually just cache hits, not interesting
+	)
+
+	@override
+	def filter(self, record: logging.LogRecord) -> bool:
+		"""Return False to suppress log records matching noise patterns."""
+		message = record.getMessage()
+		# Suppress if message contains any noise pattern
+		return not any(pattern in message for pattern in self.SUPPRESS_PATTERNS)
+
+
+def get_log_config(default_level: str = "info") -> dict[str, Any]:
+	"""Get uvicorn logging config with noise filter."""
+	return {
+		"version": 1,
+		"disable_existing_loggers": False,
+		"filters": {
+			"filter_noisy_requests": {
+				"()": "pulse.cli.uvicorn_log_config.FilterNoisyRequests",
+			},
+		},
+		"formatters": {
+			"default": {
+				"()": "uvicorn.logging.DefaultFormatter",
+				"fmt": "%(levelprefix)s %(message)s",
+				"use_colors": None,
+			},
+			"access": {
+				"()": "uvicorn.logging.AccessFormatter",
+				"fmt": '%(levelprefix)s %(client_addr)s - "%(request_line)s" %(status_code)s',
+			},
+		},
+		"handlers": {
+			"default": {
+				"formatter": "default",
+				"class": "logging.StreamHandler",
+				"stream": "ext://sys.stderr",
+			},
+			"access": {
+				"formatter": "access",
+				"class": "logging.StreamHandler",
+				"stream": "ext://sys.stdout",
+				"filters": ["filter_noisy_requests"],
+			},
+		},
+		"loggers": {
+			"uvicorn": {"handlers": ["default"], "level": default_level.upper()},
+			"uvicorn.error": {"level": "INFO"},
+			"uvicorn.access": {
+				"handlers": ["access"],
+				"level": "INFO",
+				"propagate": False,
+			},
+		},
+	}

pulse/codegen/codegen.py

@@ -4,6 +4,7 @@ from collections.abc import Sequence
 from dataclasses import dataclass
 from pathlib import Path
 
+from pulse.cli.helpers import ensure_gitignore_has
 from pulse.codegen.templates.layout import LAYOUT_TEMPLATE
 from pulse.codegen.templates.route import CssModuleImport, render_route
 from pulse.codegen.templates.routes_ts import (
@@ -107,8 +108,14 @@ class Codegen:
 		return self.cfg.pulse_path
 
 	def generate_all(
-		self, server_address: str, internal_server_address: str | None = None
+		self,
+		server_address: str,
+		internal_server_address: str | None = None,
+		api_prefix: str = "",
 	):
+		# Ensure generated files are gitignored
+		ensure_gitignore_has(self.cfg.web_root, f"app/{self.cfg.pulse_dir}/")
+
 		self._copied_css_modules = set()
 		self._css_module_dest = {}
 		self._css_name_registry = NameRegistry()
@@ -116,7 +123,9 @@ class Codegen:
 		# Keep track of all generated files
 		generated_files = set(
 			[
-				self.generate_layout_tsx(server_address, internal_server_address),
+				self.generate_layout_tsx(
+					server_address, internal_server_address, api_prefix
+				),
 				self.generate_routes_ts(),
 				self.generate_routes_runtime_ts(),
 				*(
@@ -137,13 +146,17 @@ class Codegen:
 					logger.warning(f"Could not remove stale file {path}: {e}")
 
 	def generate_layout_tsx(
-		self, server_address: str, internal_server_address: str | None = None
+		self,
+		server_address: str,
+		internal_server_address: str | None = None,
+		api_prefix: str = "",
 	):
 		"""Generates the content of _layout.tsx"""
 		content = str(
 			LAYOUT_TEMPLATE.render_unicode(
 				server_address=server_address,
 				internal_server_address=internal_server_address or server_address,
+				api_prefix=api_prefix,
 			)
 		)
 		# The underscore avoids an eventual naming conflict with a generated

pulse/codegen/templates/layout.py

@@ -10,6 +10,7 @@ import { useLoaderData } from "react-router";
 // This config is used to initialize the client
 export const config: PulseConfig = {
   serverAddress: "${server_address}",
+  apiPrefix: "${api_prefix}",
 };
 
 
@@ -26,7 +27,7 @@ export async function loader(args: LoaderFunctionArgs) {
   if (cookie) fwd.set("cookie", cookie);
   if (authorization) fwd.set("authorization", authorization);
   fwd.set("content-type", "application/json");
-  const res = await fetch("${internal_server_address}/prerender", {
+  const res = await fetch(`${internal_server_address}$${"{"}config.apiPrefix}/prerender`, {
     method: "POST",
     headers: fwd,
     body: JSON.stringify({ paths, routeInfo: extractServerRouteInfo(args) }),
@@ -53,7 +54,7 @@ export async function clientLoader(args: ClientLoaderFunctionArgs) {
     typeof window !== "undefined" && typeof sessionStorage !== "undefined"
       ? (sessionStorage.getItem("__PULSE_RENDER_ID") ?? undefined) 
       : undefined;
-  const res = await fetch("${server_address}/prerender", {
+  const res = await fetch(`$${"{"}config.serverAddress}$${"{"}config.apiPrefix}/prerender`, {
     method: "POST",
     headers: { "content-type": "application/json" },
     credentials: "include",

pulse/cookies.py

@@ -8,7 +8,7 @@ from fastapi import Request, Response
 from pulse.hooks.runtime import set_cookie
 
 if TYPE_CHECKING:
-	from pulse.app import DeploymentMode
+	from pulse.app import PulseMode
 
 
 @dataclass
@@ -73,11 +73,11 @@ class SetCookie(Cookie):
 
 
 def session_cookie(
-	mode: "DeploymentMode",
+	mode: "PulseMode",
 	name: str = "pulse.sid",
 	max_age_seconds: int = 7 * 24 * 3600,
 ):
-	if mode == "dev":
+	if mode == "single-server":
 		return Cookie(
 			name,
 			domain=None,
@@ -85,7 +85,7 @@ def session_cookie(
 			samesite="lax",
 			max_age_seconds=max_age_seconds,
 		)
-	elif mode == "same_host" or mode == "subdomains":
+	elif mode == "subdomains":
 		return Cookie(
 			name,
 			domain=None,  # to be set later
@@ -137,34 +137,35 @@ def _base_domain(host: str) -> str:
 	return host[i + 1 :] if i != -1 else host
 
 
-def compute_cookie_domain(mode: "DeploymentMode", server_address: str) -> str | None:
+def compute_cookie_domain(mode: "PulseMode", server_address: str) -> str | None:
 	host = _parse_host(server_address)
-	if mode == "dev" or not host:
+	if mode == "single-server" or not host:
 		return None
-	if mode == "same_host":
-		return host
 	if mode == "subdomains":
 		return "." + _base_domain(host)
 	return None
 
 
-def cors_options(mode: "DeploymentMode", server_address: str) -> CORSOptions:
+def cors_options(mode: "PulseMode", server_address: str) -> CORSOptions:
 	host = _parse_host(server_address) or "localhost"
 	opts: CORSOptions = {
 		"allow_credentials": True,
 		"allow_methods": ["*"],
 		"allow_headers": ["*"],
 	}
-	if mode == "dev":
-		opts["allow_origin_regex"] = ".*"
-		return opts
-	elif mode == "same_host":
-		opts["allow_origin_regex"] = rf"^https?://{host}(:\\d+)?$"
-		return opts
-	elif mode == "subdomains":
+	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:
 		raise ValueError(f"Unsupported deployment mode '{mode}'")
 

pulse/env.py

@@ -17,7 +17,7 @@ import os
 from typing import Literal
 
 # Types
-PulseMode = Literal["dev", "ci", "prod"]
+PulseEnv = Literal["dev", "ci", "prod"]
 
 # Keys
 ENV_PULSE_MODE = "PULSE_MODE"
@@ -26,11 +26,10 @@ ENV_PULSE_APP_DIR = "PULSE_APP_DIR"
 ENV_PULSE_HOST = "PULSE_HOST"
 ENV_PULSE_PORT = "PULSE_PORT"
 ENV_PULSE_SECRET = "PULSE_SECRET"
-ENV_PULSE_LOCK_MANAGED_BY_CLI = "PULSE_LOCK_MANAGED_BY_CLI"
 ENV_PULSE_DISABLE_CODEGEN = "PULSE_DISABLE_CODEGEN"
 
 
-class Env:
+class EnvVars:
 	def _get(self, key: str) -> str | None:
 		return os.environ.get(key)
 
@@ -40,16 +39,15 @@ class Env:
 		else:
 			os.environ[key] = value
 
-	# Pulse mode
 	@property
-	def pulse_mode(self) -> PulseMode:
+	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_mode.setter
-	def pulse_mode(self, value: PulseMode) -> None:
+	@pulse_env.setter
+	def pulse_env(self, value: PulseEnv) -> None:
 		self._set(ENV_PULSE_MODE, value)
 
 	# App file/dir
@@ -99,14 +97,6 @@ class Env:
 		self._set(ENV_PULSE_SECRET, value)
 
 	# Flags
-	@property
-	def lock_managed_by_cli(self) -> bool:
-		return self._get(ENV_PULSE_LOCK_MANAGED_BY_CLI) == "1"
-
-	@lock_managed_by_cli.setter
-	def lock_managed_by_cli(self, value: bool) -> None:
-		self._set(ENV_PULSE_LOCK_MANAGED_BY_CLI, "1" if value else None)
-
 	@property
 	def codegen_disabled(self) -> bool:
 		return self._get(ENV_PULSE_DISABLE_CODEGEN) == "1"
@@ -117,9 +107,9 @@ class Env:
 
 
 # Singleton
-env = Env()
+env = EnvVars()
 
 
 # Commonly used helpesr
 def mode():
-	return env.pulse_mode
+	return env.pulse_env