datex-studio-cli 0.4.1__tar.gz → 0.4.2__tar.gz

{datex_studio_cli-0.4.1 → datex_studio_cli-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datex-studio-cli
-Version: 0.4.1
+Version: 0.4.2
 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.4.1 → datex_studio_cli-0.4.2}/pyproject.toml

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

{datex_studio_cli-0.4.1 → datex_studio_cli-0.4.2}/src/dxs/__init__.py

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

{datex_studio_cli-0.4.1 → datex_studio_cli-0.4.2}/src/dxs/cli.py

@@ -260,6 +260,17 @@ def cli(
     # Stash for the result_callback to honor --no-update-check
     dxs_ctx.no_update_check = no_update_check
 
+    # Telemetry: record invocation start (must come before any subcommand runs).
+    # Wrapped so a telemetry bug can never block the CLI.
+    try:
+        from dxs.core.telemetry import maybe_show_first_run_notice, record_start
+
+        invoked = ctx.invoked_subcommand or "<root>"
+        record_start(argv=sys.argv[1:], command=invoked)
+        maybe_show_first_run_notice()
+    except Exception:  # noqa: BLE001
+        pass
+
 
 def _mask_token(token: str | None, visible_chars: int = 8) -> str:
     """Mask a token for display, showing only first/last few characters.
@@ -316,18 +327,30 @@ def handle_errors(f: F) -> F:
         try:
             return ctx.invoke(f, *args, **kwargs)
         except DxsError as e:
+            _record_error_silently(e)
             dxs_ctx.output_error(e)
             sys.exit(1)
         except click.ClickException:
             # Let Click handle its own exceptions
             raise
         except Exception as e:
+            _record_error_silently(e)
             dxs_ctx.output_error(e)
             sys.exit(1)
 
     return cast(F, wrapper)
 
 
+def _record_error_silently(exc: BaseException) -> None:
+    """Emit a telemetry error event; never raises."""
+    try:
+        from dxs.core.telemetry import record_error
+
+        record_error(exc)
+    except Exception:  # noqa: BLE001
+        pass
+
+
 # Import and register command groups
 # These imports are here to avoid circular imports
 def register_commands() -> None:
@@ -336,6 +359,7 @@ def register_commands() -> None:
         api,
         auth,
         config,
+        configuration,
         crm,
         datasource,
         devops,
@@ -355,6 +379,8 @@ def register_commands() -> None:
     cli.add_command(api.api)
     cli.add_command(auth.auth)
     cli.add_command(config.config)
+    cli.add_command(config.config, name="settings")
+    cli.add_command(configuration.configuration)
     cli.add_command(crm.crm)
     cli.add_command(datasource.datasource)
     cli.add_command(devops.devops)
@@ -376,14 +402,30 @@ def register_commands() -> None:
 
     cli.add_command(schema.schema)
 
+    # Telemetry subcommands (status / enable / disable / test)
+    from dxs.commands import telemetry as telemetry_cmd
+
+    cli.add_command(telemetry_cmd.telemetry)
+
 
 @cli.result_callback()
 @click.pass_context
 def _after_command(ctx: click.Context, result: Any, **kwargs: Any) -> Any:
-    """Run post-command hooks (currently: PyPI update notice)."""
+    """Run post-command hooks (telemetry success event + PyPI update notice)."""
     from dxs.utils.update_check import maybe_show_update_notice
 
     dxs_ctx: DxsContext | None = ctx.find_object(DxsContext)
+
+    # Emit a success event. handle_errors-decorated commands never reach here
+    # on failure, so the only path through this branch is a successful run.
+    try:
+        from dxs.core.telemetry import record_end
+
+        ctx_extras = _ctx_extras(dxs_ctx)
+        record_end(exit_code=0, ctx_extras=ctx_extras)
+    except Exception:  # noqa: BLE001
+        pass
+
     skip = bool(dxs_ctx and dxs_ctx.no_update_check)
     try:
         maybe_show_update_notice(skip=skip)
@@ -392,6 +434,18 @@ def _after_command(ctx: click.Context, result: Any, **kwargs: Any) -> Any:
     return result
 
 
+def _ctx_extras(dxs_ctx: "DxsContext | None") -> dict[str, Any]:
+    """Pluck branch/repo/org/env from DxsContext for telemetry events."""
+    if dxs_ctx is None:
+        return {}
+    return {
+        "branch_id": dxs_ctx.branch,
+        "repo_id": dxs_ctx.repo,
+        "org": dxs_ctx.org,
+        "env": dxs_ctx.env,
+    }
+
+
 @cli.command("update")
 @click.option(
     "--check",
@@ -438,13 +492,30 @@ register_commands()
 def main() -> None:
     """Main entry point for the CLI."""
     try:
-        cli()
-    except DxsError as e:
-        # Use the module-level format captured during CLI init
-        # (Click context is torn down before exceptions reach here)
-        formatted = format_error(e, _last_output_format)
-        click.echo(formatted, err=True)
-        sys.exit(1)
+        try:
+            cli()
+        except DxsError as e:
+            _record_error_silently(e)
+            # Use the module-level format captured during CLI init
+            # (Click context is torn down before exceptions reach here)
+            formatted = format_error(e, _last_output_format)
+            click.echo(formatted, err=True)
+            sys.exit(1)
+        except SystemExit:
+            # SystemExit from sys.exit() inside handle_errors — telemetry already
+            # recorded an error there; just propagate.
+            raise
+        except BaseException as e:
+            # Anything else escaping cli() shouldn't take telemetry with it.
+            _record_error_silently(e)
+            raise
+    finally:
+        try:
+            from dxs.core.telemetry import flush
+
+            flush(timeout=0.5)
+        except Exception:  # noqa: BLE001
+            pass
 
 
 if __name__ == "__main__":

datex_studio_cli-0.4.2/src/dxs/commands/api.py

@@ -0,0 +1,236 @@
+"""Raw API request command: dxs api [METHOD] [URL] [PAYLOAD]."""
+
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+import click
+import httpx
+
+from dxs.cli import DxsContext, pass_context
+from dxs.core.auth import get_access_token, require_auth
+from dxs.utils.config import get_settings, is_restricted_mode
+from dxs.utils.errors import ApiError, RestrictedModeError
+from dxs.utils.responses import single
+
+
+@click.command()
+@click.argument(
+    "method", type=click.Choice(["GET", "POST", "PUT", "PATCH", "DELETE"], case_sensitive=False)
+)
+@click.argument("url")
+@click.argument("payload", required=False, default=None)
+@click.option(
+    "--data-file",
+    "-D",
+    "data_file",
+    type=click.Path(exists=True, dir_okay=False, readable=True, path_type=Path),
+    default=None,
+    help="Read JSON request body from a file (avoids shell escaping for large payloads).",
+)
+@click.option(
+    "--output-file",
+    "-O",
+    "output_file",
+    type=click.Path(dir_okay=False, writable=True, path_type=Path),
+    default=None,
+    help="Write the response body to a file. Implies --raw.",
+)
+@click.option(
+    "--raw",
+    is_flag=True,
+    default=False,
+    help="Print only the response body (no envelope) as JSON to stdout. Useful for piping to jq.",
+)
+@click.option(
+    "--headers",
+    "-H",
+    multiple=True,
+    help="Additional headers in format 'Key: Value'",
+)
+@pass_context
+@require_auth
+def api(
+    ctx: DxsContext,
+    method: str,
+    url: str,
+    payload: str | None,
+    data_file: Path | None,
+    output_file: Path | None,
+    raw: bool,
+    headers: tuple[str, ...],
+) -> None:
+    """Make raw API requests with automatic authentication.
+
+    Automatically adds Bearer token authentication and handles the HTTP request.
+    Useful for testing and exploring API endpoints.
+
+    \b
+    Arguments:
+        METHOD   HTTP method (GET, POST, PUT, PATCH, DELETE)
+        URL      Full URL or relative path (e.g., /organizations/mine)
+        PAYLOAD  JSON payload for POST/PUT/PATCH (optional; alternative: --data-file)
+
+    \b
+    Options:
+        -D, --data-file    Read JSON body from a file (recommended for large payloads)
+        -O, --output-file  Write response body to a file (implies --raw)
+        --raw              Emit only the response body (no envelope) for piping
+        -H, --headers      Additional headers (repeatable)
+
+    \b
+    Examples:
+        dxs api GET /organizations/mine
+        dxs api GET /applications/64/hubconfigurations/8642750 --raw -O hub.json
+        dxs api PUT /applications/64/hubconfigurations/8642750 --data-file hub.json
+        dxs api POST /applications -D payload.json
+        dxs api GET /branches -H "X-Custom: value"
+    """
+    if payload is not None and data_file is not None:
+        raise ApiError(
+            message="Pass either a positional PAYLOAD or --data-file, not both.",
+            code="DXS-API-PAYLOAD-002",
+            suggestions=["Drop one of the two arguments and re-run."],
+        )
+
+    # --output-file implies --raw (writing an envelope to disk would defeat the purpose).
+    if output_file is not None:
+        raw = True
+
+    # Block mutating methods in restricted mode
+    if is_restricted_mode() and method.upper() != "GET":
+        raise RestrictedModeError(
+            command_name=f"api {method.upper()}",
+            reason="performs mutating API requests",
+        )
+
+    settings = get_settings()
+    token = get_access_token()
+
+    # Determine if URL is relative or absolute
+    if url.startswith("http://") or url.startswith("https://"):
+        full_url = url
+    else:
+        # Relative path - prepend base URL
+        base_url = settings.api_base_url.rstrip("/")
+        path = url if url.startswith("/") else f"/{url}"
+        full_url = f"{base_url}{path}"
+
+    ctx.log(f"Making {method} request to {full_url}")
+
+    # Build headers
+    request_headers = {
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+    }
+
+    # Parse additional headers
+    for header in headers:
+        if ":" in header:
+            key, value = header.split(":", 1)
+            request_headers[key.strip()] = value.strip()
+
+    # Resolve and parse payload from positional arg or --data-file
+    payload_data = None
+    payload_source: str | None = None
+    if data_file is not None:
+        payload_source = f"--data-file {data_file}"
+        try:
+            payload_data = json.loads(data_file.read_text(encoding="utf-8"))
+        except json.JSONDecodeError as e:
+            raise ApiError(
+                message=f"Invalid JSON in {data_file}: {e}",
+                code="DXS-API-PAYLOAD-001",
+                suggestions=[f"Validate the file with: python -m json.tool {data_file}"],
+            ) from e
+    elif payload:
+        payload_source = "positional argument"
+        try:
+            payload_data = json.loads(payload)
+        except json.JSONDecodeError as e:
+            raise ApiError(
+                message=f"Invalid JSON payload: {e}",
+                code="DXS-API-PAYLOAD-001",
+                suggestions=[
+                    "Ensure the payload is valid JSON",
+                    "For large or complex bodies, use --data-file PATH instead.",
+                ],
+            ) from e
+
+    # Make the request
+    try:
+        with httpx.Client(timeout=settings.api_timeout, verify=settings.verify_ssl) as client:
+            response = client.request(
+                method=method.upper(),
+                url=full_url,
+                headers=request_headers,
+                json=payload_data if payload_data else None,
+            )
+
+            # Decode body once
+            try:
+                body: Any = response.json()
+                body_is_json = True
+            except Exception:
+                body = response.text
+                body_is_json = False
+
+            if raw:
+                _emit_raw(ctx, body, body_is_json, output_file)
+                return
+
+            response_data: dict[str, Any] = {
+                "status_code": response.status_code,
+                "headers": dict(response.headers),
+                "url": str(response.url),
+                "method": method.upper(),
+                "body": body,
+                "request": {
+                    "url": full_url,
+                    "method": method.upper(),
+                    "headers": request_headers,
+                },
+            }
+            if payload_data:
+                response_data["request"]["payload"] = payload_data
+            if payload_source:
+                response_data["request"]["payload_source"] = payload_source
+
+            ctx.output(
+                single(
+                    item=response_data,
+                    semantic_key="api_response",
+                )
+            )
+
+    except httpx.RequestError as e:
+        raise ApiError(
+            message=f"Request failed: {e}",
+            code="DXS-API-REQUEST-001",
+            details={"url": full_url, "error": str(e)},
+        ) from e
+
+
+def _emit_raw(
+    ctx: DxsContext,
+    body: Any,
+    body_is_json: bool,
+    output_file: Path | None,
+) -> None:
+    """Print or save the response body without the envelope."""
+    if body_is_json:
+        rendered = json.dumps(body, indent=2, sort_keys=False, ensure_ascii=False)
+    else:
+        rendered = body if isinstance(body, str) else str(body)
+
+    if output_file is not None:
+        output_file.write_text(rendered, encoding="utf-8")
+        ctx.log(f"Wrote response body to {output_file}")
+        return
+
+    sys.stdout.write(rendered)
+    if not rendered.endswith("\n"):
+        sys.stdout.write("\n")
+    sys.stdout.flush()

{datex_studio_cli-0.4.1 → datex_studio_cli-0.4.2}/src/dxs/commands/auth.py

@@ -581,8 +581,23 @@ def list_identities(ctx: DxsContext) -> None:
 
 @auth.command()
 @click.argument("identifier")
+@click.option(
+    "--client-id",
+    default=None,
+    help="Footprint API app registration client ID (for daemon auth)",
+)
+@click.option(
+    "--client-secret",
+    default=None,
+    help="Footprint API app registration client secret (for daemon auth)",
+)
 @pass_context
-def switch(ctx: DxsContext, identifier: str) -> None:
+def switch(
+    ctx: DxsContext,
+    identifier: str,
+    client_id: str | None,
+    client_secret: str | None,
+) -> None:
     """Switch to a different identity or organization.
 
     Auto-detects the identifier type:
@@ -593,15 +608,35 @@ def switch(ctx: DxsContext, identifier: str) -> None:
     this command will initiate device code flow to authenticate against the
     external tenant if no cached identity exists for that tenant.
 
+    Use --client-id and --client-secret together to configure daemon (client
+    credentials) authentication for the Footprint API on the target identity.
+    Required for cross-tenant access where OBO flow is not available. The
+    credentials are stored on the identity and reused for subsequent OData
+    queries.
+
     \b
     Examples:
         dxs auth switch user@acme.com    # Switch by username (email)
         dxs auth switch CAG              # Switch by organization name
+        dxs auth switch CAG --client-id <id> --client-secret <secret>
     """
+    if bool(client_id) != bool(client_secret):
+        ctx.output_error(
+            ValidationError(
+                message="--client-id and --client-secret must be provided together",
+                code="DXS-AUTH-015",
+                suggestions=[
+                    "Provide both --client-id and --client-secret for daemon auth",
+                    "Or omit both to switch without changing daemon credentials",
+                ],
+            )
+        )
+        raise SystemExit(1)
+
     if "@" in identifier:
-        _switch_by_username(ctx, identifier)
+        _switch_by_username(ctx, identifier, client_id=client_id, client_secret=client_secret)
     else:
-        _switch_by_organization(ctx, identifier)
+        _switch_by_organization(ctx, identifier, client_id=client_id, client_secret=client_secret)
 
 
 @auth.command()
@@ -681,7 +716,11 @@ def consent(ctx: DxsContext, org: str, open: bool) -> None:
     footprint_consent_url = f"{base_consent}?client_id={fp_client_id}" if fp_client_id else None
 
     consent_apps = [
-        {"name": "Datex Studio API", "client_id": settings.azure_client_id, "url": datex_consent_url},
+        {
+            "name": "Datex Studio API",
+            "client_id": settings.azure_client_id,
+            "url": datex_consent_url,
+        },
     ]
     if footprint_consent_url and fp_client_id:
         consent_apps.append(
@@ -867,7 +906,12 @@ def _build_token_status(claims: dict[str, Any]) -> dict[str, Any]:
     return status
 
 
-def _switch_by_username(ctx: DxsContext, username: str) -> None:
+def _switch_by_username(
+    ctx: DxsContext,
+    username: str,
+    client_id: str | None = None,
+    client_secret: str | None = None,
+) -> None:
     """Switch to an identity by username (original behavior)."""
     cache = MultiIdentityTokenCache()
 
@@ -922,22 +966,32 @@ def _switch_by_username(ctx: DxsContext, username: str) -> None:
         )
         raise SystemExit(1) from None
 
-    ctx.output(
-        single(
-            item={
-                "status": "switched",
-                "message": f"Switched to {username}",
-                "previous_identity": previous_username,
-                "active_identity": username,
-                "organization": new_identity.organization_name,
-                "organization_id": new_identity.organization_id,
-            },
-            semantic_key="authentication",
-        )
-    )
+    # Persist daemon credentials on the identity if supplied
+    if client_id and client_secret:
+        updated = cache.update_identity_daemon_creds(username, client_id, client_secret)
+        if updated is not None:
+            new_identity = updated
+
+    item: dict[str, Any] = {
+        "status": "switched",
+        "message": f"Switched to {username}",
+        "previous_identity": previous_username,
+        "active_identity": username,
+        "organization": new_identity.organization_name,
+        "organization_id": new_identity.organization_id,
+    }
+    if new_identity.footprint_client_id:
+        item["footprint_daemon_auth"] = "configured"
+
+    ctx.output(single(item=item, semantic_key="authentication"))
 
 
-def _switch_by_organization(ctx: DxsContext, org_name: str) -> None:
+def _switch_by_organization(
+    ctx: DxsContext,
+    org_name: str,
+    client_id: str | None = None,
+    client_secret: str | None = None,
+) -> None:
     """Switch to an organization, authenticating against external tenant if needed."""
 
     cache = MultiIdentityTokenCache()
@@ -946,7 +1000,14 @@ def _switch_by_organization(ctx: DxsContext, org_name: str) -> None:
     existing_by_org = cache.get_identity_by_org_name(org_name)
     if existing_by_org:
         # We have an identity for this org - switch to it
-        _activate_existing_identity(ctx, cache, existing_by_org, org_name)
+        _activate_existing_identity(
+            ctx,
+            cache,
+            existing_by_org,
+            org_name,
+            client_id=client_id,
+            client_secret=client_secret,
+        )
         return
 
     # Step 2: Fetch organization details from API
@@ -992,7 +1053,14 @@ def _switch_by_organization(ctx: DxsContext, org_name: str) -> None:
                 org_info.id,
                 org_info.name,
             )
-            _activate_existing_identity(ctx, cache, existing_by_tenant, org_name)
+            _activate_existing_identity(
+                ctx,
+                cache,
+                existing_by_tenant,
+                org_name,
+                client_id=client_id,
+                client_secret=client_secret,
+            )
             return
 
     # Step 5: Need to authenticate against external tenant
@@ -1006,7 +1074,9 @@ def _switch_by_organization(ctx: DxsContext, org_name: str) -> None:
         )
         raise SystemExit(1)
 
-    _authenticate_external_tenant(ctx, cache, org_info)
+    _authenticate_external_tenant(
+        ctx, cache, org_info, client_id=client_id, client_secret=client_secret
+    )
 
 
 def _activate_existing_identity(
@@ -1014,6 +1084,8 @@ def _activate_existing_identity(
     cache: MultiIdentityTokenCache,
     identity: Any,
     org_name: str,
+    client_id: str | None = None,
+    client_secret: str | None = None,
 ) -> None:
     """Activate an existing cached identity."""
     # Check if token is expired
@@ -1034,20 +1106,27 @@ def _activate_existing_identity(
 
     cache.set_active_identity(identity.identity_key)
 
-    ctx.output(
-        single(
-            item={
-                "status": "switched",
-                "message": f"Switched to organization {org_name}",
-                "previous_identity": previous_username,
-                "active_identity": identity.account_username,
-                "organization": identity.organization_name,
-                "organization_id": identity.organization_id,
-                "external_tenant": identity.external_entra_id,
-            },
-            semantic_key="authentication",
+    # Persist daemon credentials on the identity if supplied
+    if client_id and client_secret and identity.account_username:
+        updated = cache.update_identity_daemon_creds(
+            identity.account_username, client_id, client_secret
         )
-    )
+        if updated is not None:
+            identity = updated
+
+    item: dict[str, Any] = {
+        "status": "switched",
+        "message": f"Switched to organization {org_name}",
+        "previous_identity": previous_username,
+        "active_identity": identity.account_username,
+        "organization": identity.organization_name,
+        "organization_id": identity.organization_id,
+        "external_tenant": identity.external_entra_id,
+    }
+    if identity.footprint_client_id:
+        item["footprint_daemon_auth"] = "configured"
+
+    ctx.output(single(item=item, semantic_key="authentication"))
 
 
 def _fetch_organization_by_name(ctx: DxsContext, org_name: str) -> Any:

{datex_studio_cli-0.4.1 → datex_studio_cli-0.4.2}/src/dxs/commands/config.py

@@ -10,10 +10,14 @@ from dxs.utils.restricted import restrict_in_restricted_mode
 
 @click.group()
 def config() -> None:
-    """Configuration commands.
+    """CLI settings stored in ~/.datex/config.yaml.
 
-    Manage CLI configuration stored in ~/.datex/config.yaml.
-    Configuration can also be set via environment variables (prefixed with DXS_).
+    Manages local CLI configuration (api_base_url, default_org, etc.). Settings
+    can also be supplied via environment variables (prefixed with DXS_).
+
+    Aliased as `dxs settings` to disambiguate from `dxs configuration`, which
+    operates on platform configuration objects (hubs, grids, forms, flows, etc.)
+    on a Datex Studio branch.
     """
     pass