datex-studio-cli 0.5.4__tar.gz → 0.5.5__tar.gz

{datex_studio_cli-0.5.4 → datex_studio_cli-0.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: datex-studio-cli
-Version: 0.5.4
+Version: 0.5.5
 Summary: CLI for Datex Studio low-code platform, designed for LLM-based AI agents
 Project-URL: Homepage, https://github.com/datex/datex-studio-cli
 Project-URL: Documentation, https://github.com/datex/datex-studio-cli

{datex_studio_cli-0.5.4 → datex_studio_cli-0.5.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "datex-studio-cli"
-version = "0.5.4"
+version = "0.5.5"
 description = "CLI for Datex Studio low-code platform, designed for LLM-based AI agents"
 readme = "README.md"
 license = "MIT"

{datex_studio_cli-0.5.4 → datex_studio_cli-0.5.5}/src/dxs/__init__.py

@@ -1,4 +1,4 @@
 """Datex Studio CLI - Command-line interface for Datex Studio platform."""
 
-__version__ = "0.5.4"
+__version__ = "0.5.5"
 __app_name__ = "dxs"

{datex_studio_cli-0.5.4 → datex_studio_cli-0.5.5}/src/dxs/cli.py

@@ -1,8 +1,10 @@
 """Main CLI entry point for Datex Studio CLI."""
 
+import errno
+import os
 import sys
 from collections.abc import Callable
-from typing import Any, TypeVar, cast
+from typing import Any, NoReturn, TypeVar, cast
 
 import click
 
@@ -136,7 +138,16 @@ class DxsGroup(click.Group):
         so ``_resolve_command_path`` reads them back from ``ctx.meta``.
         """
         ctx.meta[RAW_ARGS_META_KEY] = [*getattr(ctx, "_protected_args", []), *ctx.args]
-        return super().invoke(ctx)
+        try:
+            return super().invoke(ctx)
+        except (BrokenPipeError, OSError) as e:
+            # Handle a closed stdout here, inside Click's own invoke, rather
+            # than around cli(): Click catches EPIPE itself and exits 1, so by
+            # the time main() sees anything it is a SystemExit. Raising
+            # SystemExit from here passes straight through that handler.
+            if not _is_broken_pipe(e):
+                raise
+            _exit_broken_pipe()
 
     def _is_gated(self, cmd_name: str) -> bool:
         """Whether ``cmd_name`` is Datex-internal and unavailable to this user."""
@@ -547,6 +558,15 @@ def handle_errors(f: F) -> F:
             _record_error_silently(e, dxs_ctx)
             dxs_ctx.output_error(e)
             sys.exit(1)
+        except (BrokenPipeError, OSError) as e:
+            # A closed stdout is not a command failure: re-raise so main()
+            # can silence it. Rendering an error envelope here would both
+            # lie to the user and record a bogus command.error.
+            if not _is_broken_pipe(e):
+                _record_error_silently(e, dxs_ctx)
+                dxs_ctx.output_error(e)
+                sys.exit(1)
+            raise
         except (click.ClickException, click.Abort, click.exceptions.Exit):
             # Let Click handle its own exceptions and control-flow signals
             # (Abort from confirm(abort=True), Exit from ctx.exit) — these are
@@ -560,6 +580,67 @@ def handle_errors(f: F) -> F:
     return cast(F, wrapper)
 
 
+#: 128 + SIGPIPE, the conventional shell status for "died because the pipe closed".
+BROKEN_PIPE_EXIT_CODE = 141
+
+
+def _is_broken_pipe(exc: BaseException) -> bool:
+    """True when ``exc`` is stdout's consumer going away rather than a failure.
+
+    POSIX raises ``BrokenPipeError`` (EPIPE). Windows has no SIGPIPE and instead
+    fails the underlying ``flush()`` with ``OSError [Errno 22] Invalid argument``
+    — so EINVAL counts only there, since on POSIX it means a hundred other
+    things and must not be mistaken for a closed pipe.
+    """
+    if isinstance(exc, BrokenPipeError):
+        return True
+    if not isinstance(exc, OSError):
+        return False
+    if exc.errno == errno.EPIPE:
+        return True
+    return exc.errno == errno.EINVAL and sys.platform == "win32"
+
+
+def _silence_stdout() -> None:
+    """Point stdout at devnull so interpreter shutdown cannot re-raise.
+
+    Python flushes the standard streams on exit; against a closed pipe that
+    raises a second time, past any handler we control, and CPython prints
+    "Exception ignored in: <_io.TextIOWrapper name='<stdout>'>". Redirecting the
+    file descriptor is the documented way to avoid it. Best-effort: under pytest
+    or Click's CliRunner stdout is a StringIO with no real fileno.
+    """
+    devnull = None
+    try:
+        devnull = os.open(os.devnull, os.O_WRONLY)
+        os.dup2(devnull, sys.stdout.fileno())
+    except Exception:  # noqa: BLE001 - silencing output must never itself fail
+        pass
+    finally:
+        if devnull is not None:
+            try:
+                os.close(devnull)
+            except OSError:
+                pass
+
+
+def _exit_broken_pipe() -> NoReturn:
+    """Leave quietly after the consumer of stdout went away."""
+    _silence_stdout()
+    _record_broken_pipe_silently()
+    sys.exit(BROKEN_PIPE_EXIT_CODE)
+
+
+def _record_broken_pipe_silently() -> None:
+    """Record a closed pipe as a completed run, never as command.error."""
+    try:
+        from dxs.core.telemetry import record_end
+
+        record_end(exit_code=BROKEN_PIPE_EXIT_CODE)
+    except Exception:  # noqa: BLE001
+        pass
+
+
 def _record_error_silently(exc: BaseException, dxs_ctx: "DxsContext | None" = None) -> None:
     """Emit a telemetry error event; never raises.
 
@@ -850,6 +931,15 @@ def main() -> None:
             # SystemExit from sys.exit() inside handle_errors — telemetry already
             # recorded an error there; just propagate.
             raise
+        except (BrokenPipeError, OSError) as e:
+            if not _is_broken_pipe(e):
+                _record_error_silently(e)
+                raise
+            # The consumer stopped reading (`| head`, an agent that moved on).
+            # Say nothing, record a completed run, and exit on the SIGPIPE
+            # convention so `set -o pipefail` scripts can still tell truncated
+            # output from a clean one.
+            _exit_broken_pipe()
         except BaseException as e:
             # Anything else escaping cli() shouldn't take telemetry with it.
             _record_error_silently(e)

{datex_studio_cli-0.5.4 → datex_studio_cli-0.5.5}/src/dxs/commands/document.py

@@ -12,7 +12,14 @@ import click
 import yaml
 
 from dxs.cli import DxsContext, pass_context
-from dxs.core.api import ApiClient, BranchEndpoints, ConfigurationEndpoints, fetch_references
+from dxs.core.api import (
+    ApiClient,
+    BranchEndpoints,
+    ConfigurationEndpoints,
+    fetch_references,
+    reference_branch_ids,
+    resolve_references,
+)
 from dxs.core.auth import require_auth
 from dxs.core.cache import ConfigIndex, get_cache
 from dxs.core.graph import (
@@ -265,12 +272,16 @@ def _fetch_library_branches(
 
     try:
         refs = fetch_references(client, branch_id)
+        resolved = resolve_references(client, refs)
+        library_map = reference_branch_ids(refs, resolved)
 
-        for ref in refs:
-            ref_name = ref.get("referenceName", "")
-            app_id = ref.get("applicationId")
-            if ref_name and app_id:
-                library_map[ref_name] = app_id
+        # A library we cannot place on a branch cannot be downloaded. Say so —
+        # silently returning fewer libraries is what made this failure invisible.
+        unresolved = sorted(
+            name for ref in refs if (name := ref.get("referenceName")) and name not in library_map
+        )
+        for name in unresolved:
+            _progress(f"    Warning: could not resolve library '{name}' to a branch")
 
         # Fetch branch statuses for all library branches (for caching decisions)
         for lib_branch_id in set(library_map.values()):
@@ -281,8 +292,8 @@ def _fetch_library_branches(
             except Exception:
                 branch_statuses[lib_branch_id] = 0  # Not cacheable if unknown
 
-    except Exception:
-        pass
+    except Exception as exc:
+        _progress(f"    Warning: failed to discover libraries: {exc}")
 
     return library_map, branch_statuses
 

{datex_studio_cli-0.5.4 → datex_studio_cli-0.5.5}/src/dxs/commands/odata.py

@@ -16,7 +16,7 @@ from typing import Any
 import click
 import httpx
 
-from dxs.cli import DxsContext, pass_context
+from dxs.cli import DxsContext, handle_errors, pass_context
 from dxs.core.api import ApiClient
 from dxs.core.api.endpoints import ApiConnectionEndpoints
 from dxs.core.auth import require_auth
@@ -25,6 +25,7 @@ from dxs.core.footprint.edmx_parser import parse_edmx
 from dxs.core.footprint.metadata import MetadataCache
 from dxs.utils.config import get_settings
 from dxs.utils.errors import ApiError, AuthenticationError, ValidationError
+from dxs.utils.http_errors import raise_for_transport_error
 from dxs.utils.resolvers import resolve_connection_option
 from dxs.utils.responses import list_response, single
 
@@ -88,6 +89,7 @@ def odata() -> None:
 )
 @pass_context
 @require_auth
+@handle_errors
 def execute(
     ctx: DxsContext,
     connection_id: int | None,
@@ -151,6 +153,7 @@ def execute(
         token=token,
         timeout=settings.api_timeout,
         apply_oso_security=oso_security,
+        verify=settings.verify_ssl,
     )
 
     ctx.output(
@@ -372,6 +375,7 @@ def _execute_footprint_odata(
     token: str,
     timeout: int = 30,
     apply_oso_security: bool = False,
+    verify: bool = True,
 ) -> dict[str, Any]:
     """Execute an OData GET request against the Footprint API."""
     url = f"{connection_string}/{query}"
@@ -386,11 +390,14 @@ def _execute_footprint_odata(
     if _is_daemon_mode():
         headers["x-caller"] = _build_x_caller_header(token, apply_oso_security=apply_oso_security)
 
-    with httpx.Client(timeout=timeout) as client:
-        response = client.get(url, headers=headers)
-        _raise_for_footprint_error(response)
-        result: dict[str, Any] = response.json()
-        return result
+    try:
+        with httpx.Client(timeout=timeout, verify=verify) as client:
+            response = client.get(url, headers=headers)
+            _raise_for_footprint_error(response)
+            result: dict[str, Any] = response.json()
+            return result
+    except httpx.TransportError as e:
+        raise_for_transport_error(e, url, what="the Footprint API", timeout=timeout)
 
 
 @odata.group()
@@ -449,17 +456,20 @@ def _fetch_metadata(
 
     x_caller = base64.b64encode(json.dumps({}).encode()).decode()
 
-    with httpx.Client(timeout=settings.api_timeout) as client:
-        response = client.get(
-            url,
-            headers={
-                "Authorization": f"Bearer {token}",
-                "x-caller": x_caller,
-                "Accept": "application/xml",
-            },
-        )
-        _raise_for_footprint_error(response)
-        xml = response.text
+    try:
+        with httpx.Client(timeout=settings.api_timeout, verify=settings.verify_ssl) as client:
+            response = client.get(
+                url,
+                headers={
+                    "Authorization": f"Bearer {token}",
+                    "x-caller": x_caller,
+                    "Accept": "application/xml",
+                },
+            )
+            _raise_for_footprint_error(response)
+            xml = response.text
+    except httpx.TransportError as e:
+        raise_for_transport_error(e, url, what="the Footprint API", timeout=settings.api_timeout)
 
     cache.put(resolved_id, xml, connection_name=connection_name)
     ctx.log("Metadata cached.")
@@ -510,6 +520,7 @@ def _add_connection_options(f: Any) -> Any:
 @_add_connection_options
 @pass_context
 @require_auth
+@handle_errors
 def fetch(
     ctx: DxsContext,
     connection_id: int | None,
@@ -544,6 +555,7 @@ def fetch(
 @_add_connection_options
 @pass_context
 @require_auth
+@handle_errors
 def entities(
     ctx: DxsContext,
     connection_id: int | None,
@@ -587,6 +599,7 @@ def entities(
 @_add_connection_options
 @pass_context
 @require_auth
+@handle_errors
 def describe(
     ctx: DxsContext,
     entity_name: str,

{datex_studio_cli-0.5.4 → datex_studio_cli-0.5.5}/src/dxs/commands/release_notes.py

@@ -11,7 +11,10 @@ from dxs.core.api import (
     ApiClient,
     BranchEndpoints,
     SourceControlEndpoints,
+    diff_references,
     fetch_references,
+    reference_branch_id,
+    resolve_references,
 )
 from dxs.core.auth import require_auth
 from dxs.core.release_notes import (
@@ -205,28 +208,26 @@ def release_notes(
         from_deps = fetch_references(client, from_branch, direct_only=True)
         to_deps = fetch_references(client, to_branch, direct_only=True)
 
-        from_by_ref = {d.get("referenceName"): d for d in from_deps}
-        to_by_ref = {d.get("referenceName"): d for d in to_deps}
-
-        for ref, dep in to_by_ref.items():
-            if ref not in from_by_ref:
-                dep_changes["added"].append(dep)
-            else:
-                from_dep = from_by_ref[ref]
-                from_ver = from_dep.get("marketPlaceApplicationVersionId")
-                to_ver = dep.get("marketPlaceApplicationVersionId")
-                if from_ver != to_ver:
-                    dep_changes["updated"].append(
-                        {
-                            "reference_name": ref,
-                            "from_branch_id": from_dep.get("applicationId"),
-                            "to_branch_id": dep.get("applicationId"),
-                        }
-                    )
-
-        for ref in from_by_ref:
-            if ref not in to_by_ref:
-                dep_changes["removed"].append(from_by_ref[ref])
+        # Diff on the resolved `version`, keyed by uniqueIdentifier — the same
+        # helper `source compare` uses, so the two commands agree. The legacy
+        # marketPlaceApplicationVersionId comparison read None on both sides and
+        # so never reported a bump.
+        diff = diff_references(from_deps, to_deps)
+        dep_changes["added"] = diff["added"]
+        dep_changes["removed"] = diff["removed"]
+
+        # Classifying an update means diffing the two packages' branches, and the
+        # reference rows no longer carry applicationId — resolve it for both sides.
+        resolved = resolve_references(client, from_deps + to_deps)
+        for entry in diff["updated"]:
+            uid = entry.get("unique_identifier")
+            entry["from_branch_id"] = reference_branch_id(
+                resolved.get((uid, entry.get("from_version")))
+            )
+            entry["to_branch_id"] = reference_branch_id(
+                resolved.get((uid, entry.get("to_version")))
+            )
+        dep_changes["updated"] = diff["updated"]
     except Exception:
         logger.debug("Failed to fetch dependencies", exc_info=True)
 
@@ -235,7 +236,15 @@ def release_notes(
     sync_only_deps: list[dict[str, Any]] = []
     if dep_changes["updated"]:
         ctx.log(f"Classifying {len(dep_changes['updated'])} dependency updates...")
-        meaningful_deps, sync_only_deps = classify_dependencies(client, dep_changes["updated"])
+        # Classification compares the two branches; an update whose branches did not
+        # resolve cannot be inspected. Report it as meaningful rather than dropping
+        # it — an unexamined bump is not evidence of a sync-only one.
+        classifiable = [
+            d for d in dep_changes["updated"] if d.get("from_branch_id") and d.get("to_branch_id")
+        ]
+        unclassifiable = [d for d in dep_changes["updated"] if d not in classifiable]
+        meaningful_deps, sync_only_deps = classify_dependencies(client, classifiable)
+        meaningful_deps.extend(unclassifiable)
 
     if include_sync:
         # Move sync-only deps into meaningful list