Merge remote-tracking branch 'origin/main' into bug/341-20260918-reject-nested-run

# Conflicts:
#	CHANGELOG.md

Author: codeforester

CHANGELOG.md

@@ -25,6 +25,10 @@ and versions are tracked in the repo-root `VERSION` file.
 
 - Reject recursive and concurrent in-process `run_app()` calls before they can
   replace another invocation's stdout or logging handlers.
+- Resolve lifecycle values through the active Typer/Click context for attached
+  commands, including renamed options, defaults, and environment variables.
+- Reject non-finite numbers in JSON and NDJSON output so emitted records remain
+  standards-compliant and failed NDJSON writes do not leave partial records.
 
 - Honor all five validated framework `log_level` values on native and attached
   user-facing streams while preserving DEBUG-level persistent diagnostics.

README.md

@@ -643,7 +643,9 @@ subcommand. Disabled and hidden options do not appear in help; renamed options
 appear only under their configured declarations.
 
 Normalized values are available as one typed `LifecycleValues` record in the
-active Click context's namespaced metadata:
+active Click context's namespaced metadata. The context argument is optional;
+when omitted, base-cli resolves the active upstream Click or supported Typer
+context automatically:
 
 ```python
 @click.pass_context

docs/json-contracts.md

@@ -58,6 +58,11 @@ contains the numeric `exit_code` and captured command stdout. A command's
 human output is represented as a JSON string, so it cannot introduce prose or
 ANSI escapes as a second stdout record.
 
+All JSON and NDJSON emitters use strict JSON serialization and reject
+non-finite numeric values (`NaN`, positive infinity, and negative infinity).
+An invalid NDJSON record is fully serialized before it is written, so it does
+not leave a partial line in the output stream.
+
 `run_id` is the lifecycle run identifier when startup reached a runtime
 context, otherwise it is `null`. Unexpected failures intentionally expose only
 the generic message `Unexpected internal error.`; diagnostics stay in logs.

lib/python/base_cli/_click_compat.py

@@ -97,8 +97,16 @@ def _vendored_typer_dialect(typer: Any) -> _VendoredClickDialect | None:
     except (ImportError, AttributeError):
         return None
 
-    core = module.core
-    exceptions = module.exceptions
+    core = getattr(module, "core", None)
+    exceptions = getattr(module, "exceptions", None)
+    echo = getattr(module, "echo", None)
+    click_exception = getattr(module, "ClickException", None)
+    abort = getattr(module, "Abort", getattr(exceptions, "Abort", getattr(core, "Abort", None)))
+    usage_error = getattr(module, "UsageError", getattr(core, "UsageError", None))
+    if core is None or exceptions is None or not callable(echo):
+        return None
+    if not isinstance(abort, type) or not isinstance(usage_error, type) or not isinstance(click_exception, type):
+        return None
 
     def option(param_decls: list[str], **attrs: Any) -> Any:
         return TyperOption(param_decls=list(param_decls), **attrs)
@@ -108,11 +116,11 @@ def option(param_decls: list[str], **attrs: Any) -> Any:
         Command=module.Command,
         Option=option,
         Path=TyperPath,
-        version_option=_vendor_version_option_factory(TyperOption, module.echo),
+        version_option=_vendor_version_option_factory(TyperOption, echo),
         exceptions=exceptions,
-        Abort=getattr(module, "Abort", getattr(exceptions, "Abort", core.Abort)),
-        UsageError=getattr(module, "UsageError", core.UsageError),
-        ClickException=module.ClickException,
+        Abort=abort,
+        UsageError=usage_error,
+        ClickException=click_exception,
     )
 
 
@@ -125,6 +133,21 @@ def dialect_for_typer(typer: Any) -> Any:
     return dialect if dialect is not None else click
 
 
+def current_context_candidates(typer: Any, click: Any) -> list[Any]:
+    """Return active contexts from Typer's dialect followed by public Click."""
+
+    dialect = dialect_for_typer(typer)
+    candidates: list[Any] = []
+    if dialect is not click:
+        get_context = getattr(dialect, "get_current_context", None)
+        if get_context is None:
+            get_context = getattr(getattr(dialect, "globals", None), "get_current_context", None)
+        if callable(get_context):
+            candidates.append(get_context(silent=True))
+    candidates.append(click.get_current_context(silent=True))
+    return candidates
+
+
 def exit_exception_type(click: Any) -> type[BaseException]:
     """Return the owning dialect's exit exception across Click variants.
 
@@ -189,4 +212,11 @@ def is_command(command: Any) -> bool:
     return dialect is not click and isinstance(command, dialect.Command)
 
 
-__all__ = ["dialect_for_command", "dialect_for_typer", "exit_exception_type", "is_command", "mark_command_dialect"]
+__all__ = [
+    "current_context_candidates",
+    "dialect_for_command",
+    "dialect_for_typer",
+    "exit_exception_type",
+    "is_command",
+    "mark_command_dialect",
+]

lib/python/base_cli/inspection.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
-import json
 from collections.abc import Mapping
 from typing import Any, Literal
 
+from .json_contracts import dumps_strict_json
+
 InspectionStatus = Literal["ok", "warn", "error"]
 
 
@@ -35,7 +36,7 @@ def render_inspection_json(
 ) -> str:
     """Serialize the stable inspection envelope with Python's JSON encoder."""
     return (
-        json.dumps(
+        dumps_strict_json(
             inspection_envelope(command=command, status=status, data=data, error=error),
             ensure_ascii=False,
             indent=2,

lib/python/base_cli/json_contracts.py

@@ -43,6 +43,7 @@
     "error_envelope",
     "success_envelope",
     "dumps_envelope",
+    "dumps_strict_json",
     "redact_json_value",
 ]
 
@@ -91,7 +92,7 @@ def dumps_envelope(envelope: Mapping[str, Any]) -> str:
     """Serialize an envelope as one compact, newline-terminated JSON record."""
 
     return (
-        json.dumps(
+        dumps_strict_json(
             redact_json_value(dict(envelope)),
             ensure_ascii=False,
             separators=(",", ":"),
@@ -100,6 +101,13 @@ def dumps_envelope(envelope: Mapping[str, Any]) -> str:
     )
 
 
+def dumps_strict_json(value: Any, **kwargs: Any) -> str:
+    """Serialize JSON while rejecting non-finite numeric values."""
+
+    kwargs["allow_nan"] = False
+    return json.dumps(value, **kwargs)
+
+
 def redact_json_value(value: Any, *, _key: str | None = None) -> Any:
     """Recursively redact secret-looking JSON keys and text values."""
 
@@ -140,7 +148,7 @@ def format(self, record: LogRecord) -> str:
             payload["details"] = {
                 "exception_type": record.exc_info[0].__name__,
             }
-        return json.dumps(payload, ensure_ascii=False, separators=(",", ":"))
+        return dumps_strict_json(payload, ensure_ascii=False, separators=(",", ":"))
 
 
 def _timestamp(value: float) -> str:

lib/python/base_cli/lifecycle_options.py

@@ -186,7 +186,26 @@ def get_lifecycle_values(click_context: Any | None = None) -> LifecycleValues:
             import click
         except ImportError as exc:
             raise RuntimeError("Click is required to inspect lifecycle option values.") from exc
-        click_context = click.get_current_context(silent=True)
+        candidates: list[Any] = []
+        try:
+            import typer
+        except ImportError:
+            pass
+        else:
+            from ._click_compat import current_context_candidates
+
+            candidates.extend(current_context_candidates(typer, click))
+        if not candidates:
+            candidates.append(click.get_current_context(silent=True))
+        click_context = next(
+            (
+                candidate
+                for candidate in candidates
+                if candidate is not None
+                and isinstance(getattr(candidate, "meta", {}).get(LIFECYCLE_META_KEY), LifecycleValues)
+            ),
+            next((candidate for candidate in candidates if candidate is not None), None),
+        )
     if click_context is None:
         raise RuntimeError("Lifecycle option values are not available outside a Click invocation.")
     value = getattr(click_context, "meta", {}).get(LIFECYCLE_META_KEY)

lib/python/base_cli/output.py

@@ -15,6 +15,7 @@
 
 from ._dependencies import require_yaml
 from .integrations import try_render_rich_table
+from .json_contracts import dumps_strict_json
 
 PUBLIC_OUTPUT_FORMATS = ("text", "csv", "tsv", "yaml", "json", "ndjson")
 NDJSON_SCHEMA = "base-cli.record"
@@ -62,7 +63,10 @@ def write(self, record: StructuredRecord) -> None:
             "schema": self.schema,
             "record": dict(record),
         }
-        self.stream.write(json.dumps(payload, separators=(",", ":")))
+        # Serialize the complete record before touching the sink: with strict
+        # JSON, a nested NaN/Infinity must not leave a partial NDJSON line.
+        encoded = json.dumps(payload, separators=(",", ":"), allow_nan=False)
+        self.stream.write(encoded)
         self.stream.write("\n")
         self.stream.flush()
 
@@ -135,21 +139,23 @@ def render_records(
     resolved = resolve_output_format(requested_format, stream=target)
 
     if resolved in ("csv", "tsv"):
+        record_list = [dict(record) for record in records]
+        _validate_delimited_records(record_list, columns)
         delimiter = "," if resolved == "csv" else "\t"
         writer = csv.writer(target, delimiter=delimiter, lineterminator="\n")
-        for record in records:
-            writer.writerow([_delimited_value(record.get(key)) for _header, key in columns])
+        for row in record_list:
+            writer.writerow([_delimited_value(row.get(key)) for _header, key in columns])
         return resolved
 
     if resolved == "ndjson":
         ndjson_writer = NdjsonWriter(target)
-        for record in records:
-            ndjson_writer.write(record)
+        for structured_record in records:
+            ndjson_writer.write(structured_record)
         return resolved
 
     record_list = [dict(record) for record in records]
     if resolved == "json":
-        target.write(json.dumps(record_list, separators=(",", ":")))
+        target.write(dumps_strict_json(record_list, separators=(",", ":")))
         target.write("\n")
         return resolved
 
@@ -195,7 +201,7 @@ def render_document(
     if resolved == "text":
         return resolved
     if resolved == "json":
-        target.write(json.dumps(dict(document), indent=2))
+        target.write(dumps_strict_json(dict(document), indent=2))
         target.write("\n")
         return resolved
     if resolved == "yaml":
@@ -249,10 +255,23 @@ def _cell_value(value: Any) -> str:
     if isinstance(value, bool):
         return "true" if value else "false"
     if isinstance(value, (Mapping, list, tuple)):
-        return json.dumps(value, separators=(",", ":"))
+        return dumps_strict_json(value, separators=(",", ":"))
     return str(value)
 
 
+def _validate_delimited_records(
+    records: Sequence[Mapping[str, Any]],
+    columns: Sequence[tuple[str, str]],
+) -> None:
+    """Validate nested cell values before a delimited stream is touched."""
+
+    for record in records:
+        for _header, key in columns:
+            value = record.get(key)
+            if isinstance(value, (Mapping, list, tuple)):
+                dumps_strict_json(value, separators=(",", ":"))
+
+
 def _delimited_value(value: Any) -> str:
     """Return a safe scalar for redirected CSV/TSV output.
 

tests/test_json_contracts.py

@@ -52,6 +52,12 @@ def test_envelopes_have_stable_fields_and_recursive_redaction(self) -> None:
         self.assertEqual(failure["message"], "authorization=[REDACTED]")
         self.assertEqual(json.loads(base_cli.dumps_envelope(failure)), failure)
 
+    def test_json_contract_emitters_reject_nested_non_finite_values(self) -> None:
+        invalid = {"nested": [{"value": float("inf")}]}
+        envelope = base_cli.success_envelope(run_id=None, details=invalid)
+        with self.assertRaises(ValueError):
+            base_cli.dumps_envelope(envelope)
+
     def test_inline_secret_redaction_keeps_delimiters_inside_values(self) -> None:
         for value in ("abc,def", "abc;def"):
             with self.subTest(value=value):

tests/test_output.py

@@ -65,6 +65,32 @@ def isatty(self) -> bool:
 
 
 class OutputTest(unittest.TestCase):
+    def test_json_emitters_reject_non_finite_values_without_partial_output(self) -> None:
+        invalid_record = {"nested": [{"value": float("nan")}]}
+        emitters = (
+            lambda stream: render_records((invalid_record,), requested_format="json", columns=(), stream=stream),
+            lambda stream: render_document(invalid_record, requested_format="json", stream=stream),
+            lambda stream: NdjsonWriter(stream).write(invalid_record),
+        )
+
+        for emit in emitters:
+            with self.subTest(emit=emit):
+                stream = io.StringIO()
+                with self.assertRaises(ValueError):
+                    emit(stream)
+                self.assertEqual(stream.getvalue(), "")
+
+    def test_delimited_emitters_validate_nested_values_before_writing(self) -> None:
+        records = ({"name": "valid"}, {"name": {"value": float("nan")}})
+        for requested_format in ("csv", "tsv"):
+            with self.subTest(format=requested_format):
+                stream = io.StringIO()
+                with self.assertRaises(ValueError):
+                    render_records(
+                        records, requested_format=requested_format, columns=(("NAME", "name"),), stream=stream
+                    )
+                self.assertEqual(stream.getvalue(), "")
+
     def test_tsv_consumes_one_pass_iterable_without_materializing(self) -> None:
         consumed = False