mammoth-cli 2.0.43__tar.gz → 2.0.44__tar.gz

{mammoth_cli-2.0.43 → mammoth_cli-2.0.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mammoth-cli
-Version: 2.0.43
+Version: 2.0.44
 Summary: Command-line interface for the Mammoth Analytics platform
 Project-URL: homepage, https://mammoth.io
 Project-URL: repository, https://github.com/EdgeMetric/mammothsdk

{mammoth_cli-2.0.43 → mammoth_cli-2.0.44}/mammoth_cli/__init__.py

@@ -6,7 +6,7 @@ not implement a second HTTP client and does not call private SDK members.
 
 from __future__ import annotations
 
-__version__ = "2.0.43"
+__version__ = "2.0.44"
 
 # The versioned machine output envelope contract.
 SCHEMA_VERSION = 1

{mammoth_cli-2.0.43 → mammoth_cli-2.0.44}/mammoth_cli/app.py

@@ -384,7 +384,7 @@ class _EnvelopeGroup(TyperGroup):
             argv = kwargs.get("args")
             if argv is None:
                 argv = args[0] if args else None
-            self._render_usage_error(error, argv)
+            self.render_usage_error(error, argv)
             raise SystemExit(getattr(error, "exit_code", EXIT_USAGE)) from None
         except _ABORT_ERRORS:
             typer.echo("Aborted!", err=True)
@@ -395,7 +395,7 @@ class _EnvelopeGroup(TyperGroup):
         # in-process test runner observe the exit status as before.
         raise SystemExit(result if isinstance(result, int) else 0)
 
-    def _render_usage_error(self, error: Any, argv: Sequence[str] | None) -> None:
+    def render_usage_error(self, error: Any, argv: Sequence[str] | None) -> None:
         """Emit a usage error as the JSON envelope (machine) or Click prose (human).
 
         A *missing required argument* is reported with the stable

{mammoth_cli-2.0.43 → mammoth_cli-2.0.44}/mammoth_cli/bundled_skill/mammoth-cli/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: mammoth-cli
-version: 2.0.43
+version: 2.0.44
 description: "Use Mammoth Analytics from a terminal: install or authenticate the CLI, discover its live command contract, and safely manage projects, data, views, pipelines (join, merge, pivot, filter, clean), dashboards, exports, and handoffs."
 ---
 

{mammoth_cli-2.0.43 → mammoth_cli-2.0.44}/mammoth_cli/context/resolver.py

@@ -12,6 +12,7 @@ overrides no project at all.
 
 from __future__ import annotations
 
+from collections.abc import Mapping
 from dataclasses import dataclass
 
 from mammoth_cli.context import credentials, profiles
@@ -23,6 +24,7 @@ from mammoth_cli.errors.envelope import (
     EXIT_USAGE,
     CliError,
 )
+from mammoth_cli.runtime import embedded
 from mammoth_cli.runtime.invocation import Invocation
 
 
@@ -39,6 +41,9 @@ class ExplicitLogin:
         workspace_id: The Mammoth workspace id.
         server_prefix: A one-label server prefix, or None.
         api_token: The ``mm_...`` Bearer token, instead of a key + secret.
+        headers: Extra request headers sent on every API call, after the
+            credential headers so they override them. Set only by an
+            embedding host that forwards its caller's session.
     """
 
     api_key: str | None
@@ -46,6 +51,7 @@ class ExplicitLogin:
     workspace_id: int
     server_prefix: str | None = None
     api_token: str | None = None
+    headers: Mapping[str, str] | None = None
 
 
 @dataclass(frozen=True)
@@ -58,6 +64,7 @@ class ResolvedAuth:
         workspace_id: The Mammoth workspace id.
         base_url: The resolved API base url.
         api_token: The ``mm_...`` Bearer token, or None with a key + secret.
+        headers: Extra request headers from an embedding host, or None.
     """
 
     api_key: str | None
@@ -65,6 +72,7 @@ class ResolvedAuth:
     workspace_id: int
     base_url: str
     api_token: str | None = None
+    headers: Mapping[str, str] | None = None
 
 
 def not_authenticated_error() -> CliError:
@@ -110,7 +118,8 @@ def resolve_auth(
     """Resolve credentials, workspace id, and base url for one invocation.
 
     Credentials come from an explicit login (a secure prompt or ``--input``
-    document handed to :func:`resolve_auth` by ``auth login``), otherwise from
+    document handed to :func:`resolve_auth` by ``auth login``, or the login of
+    the current embedded call, :mod:`mammoth_cli.runtime.embedded`), otherwise from
     the selected or ``--profile`` saved profile. There is no environment
     credential path; ``mammoth auth login`` is the only way to authenticate.
 
@@ -126,6 +135,8 @@ def resolve_auth(
             ``invalid_workspace_id`` when the resolved workspace id is not a
             positive integer; endpoint errors from :func:`resolve_base_url`.
     """
+    if explicit_login is None and (call := embedded.current()) is not None:
+        explicit_login = call.login
     if explicit_login is not None:
         base_url = _endpoint(explicit_login.server_prefix)
         return ResolvedAuth(
@@ -134,6 +145,7 @@ def resolve_auth(
             workspace_id=_require_positive_workspace(explicit_login.workspace_id, source="login"),
             base_url=base_url,
             api_token=explicit_login.api_token,
+            headers=explicit_login.headers,
         )
 
     profile_name = invocation.profile or profiles.get_selected()

mammoth_cli-2.0.44/mammoth_cli/embed.py

@@ -0,0 +1,99 @@
+"""Run one CLI command in-process and return its envelope.
+
+For a host (for example a server-side agent) that runs commands for its own
+signed-in users. Each call carries its own login, is forced to machine output
+and no prompts, writes nothing to stdout or stderr, and returns the success or
+error envelope as a dict. Calls are safe to run concurrently in threads: the
+login and the captured envelope live in a context variable
+(:mod:`mammoth_cli.runtime.embedded`), and the update check, the run log and
+saved profiles are not used.
+
+Example::
+
+    from mammoth_cli.context.resolver import ExplicitLogin
+    from mammoth_cli.embed import invoke
+
+    login = ExplicitLogin(
+        api_key=None, api_secret=None, workspace_id=7, api_token="...",
+        server_prefix="app", headers={"Cookie": "..."},
+    )
+    envelope = invoke(["project", "list"], login=login)
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+from mammoth_cli.app import _ABORT_ERRORS, _USAGE_ERRORS, _root_click_command
+from mammoth_cli.context.resolver import ExplicitLogin
+from mammoth_cli.errors.envelope import EXIT_API, EXIT_INTERRUPT, EXIT_USAGE, CliError
+from mammoth_cli.runtime import embedded
+
+
+def invoke(
+    args: Sequence[str],
+    *,
+    login: ExplicitLogin,
+    project_id: int | None = None,
+    timeout: float | None = None,
+) -> dict[str, Any]:
+    """Run ``mammoth <args>`` as ``login`` and return its envelope.
+
+    Args:
+        args: The command line after ``mammoth``, for example
+            ``["view", "data", "get", "12"]``.
+        login: The credentials, endpoint and extra headers for this call.
+        project_id: The active project, sent as ``--project`` unless ``args``
+            already names one.
+        timeout: Per-request timeout in seconds, sent as ``--timeout`` unless
+            ``args`` already sets one.
+
+    Returns:
+        The success envelope (``data`` + ``meta``) or the error envelope
+        (``error``). A CLI error is returned, never raised.
+    """
+    argv = _argv(args, project_id=project_id, timeout=timeout)
+    call = embedded.EmbeddedCall(login=login)
+    token = embedded.enter(call)
+    try:
+        _run(argv)
+    finally:
+        embedded.leave(token)
+    if call.envelopes:
+        return call.envelopes[-1]
+    return _error("no_output", "This command printed text only (help or version).", EXIT_USAGE)
+
+
+def _argv(args: Sequence[str], *, project_id: int | None, timeout: float | None) -> list[str]:
+    """``args`` plus the options an embedded call always runs with."""
+    argv = list(args)
+    if project_id is not None and not _has_option(argv, "--project"):
+        argv += ["--project", str(project_id)]
+    if timeout is not None and not _has_option(argv, "--timeout"):
+        argv += ["--timeout", str(timeout)]
+    # Last, so they win over any output or input option in ``args``.
+    return [*argv, "--output", "json", "--no-input"]
+
+
+def _has_option(argv: Sequence[str], name: str) -> bool:
+    return any(token == name or token.startswith(f"{name}=") for token in argv)
+
+
+def _run(argv: list[str]) -> None:
+    """Run the command; every outcome ends as a captured envelope."""
+    root = _root_click_command()
+    try:
+        root.main(args=argv, prog_name="mammoth", standalone_mode=False)
+    except _USAGE_ERRORS as error:
+        root.render_usage_error(error, argv)
+    except _ABORT_ERRORS:
+        embedded.capture(_error("aborted", "The command was aborted.", EXIT_INTERRUPT))
+    except SystemExit:
+        return
+    except Exception as exc:  # noqa: BLE001 -- the host gets an envelope, never a traceback
+        embedded.capture(_error("internal_error", f"{type(exc).__name__}: {exc}", EXIT_API))
+
+
+def _error(code: str, message: str, exit_status: int) -> dict[str, Any]:
+    return CliError(code=code, message=message, exit_status=exit_status).to_envelope()

mammoth_cli-2.0.44/mammoth_cli/runtime/embedded.py

@@ -0,0 +1,56 @@
+"""Per-call state for an in-process (embedded) invocation.
+
+:func:`mammoth_cli.embed.invoke` runs a command inside a host process that may
+run several commands at once, each for a different user. The login and the
+captured envelope therefore live in a :class:`contextvars.ContextVar`, never in
+``os.environ`` or a profile file: each thread (or task) sees only its own.
+"""
+
+from __future__ import annotations
+
+from contextvars import ContextVar
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from mammoth_cli.context.resolver import ExplicitLogin
+
+
+@dataclass
+class EmbeddedCall:
+    """The login for one embedded call and the envelope it produced."""
+
+    login: ExplicitLogin
+    envelopes: list[dict[str, Any]] = field(default_factory=list)
+
+
+_CURRENT: ContextVar[EmbeddedCall | None] = ContextVar("mammoth_cli_embedded", default=None)
+
+
+def current() -> EmbeddedCall | None:
+    """The embedded call running in this context, or None for a normal CLI run."""
+    return _CURRENT.get()
+
+
+def active() -> bool:
+    """Whether this context runs an embedded call."""
+    return _CURRENT.get() is not None
+
+
+def capture(envelope: dict[str, Any]) -> bool:
+    """Keep ``envelope`` for the embedded caller; False when not embedded."""
+    call = _CURRENT.get()
+    if call is None:
+        return False
+    call.envelopes.append(envelope)
+    return True
+
+
+def enter(call: EmbeddedCall) -> Any:
+    """Make ``call`` current; returns the token for :func:`leave`."""
+    return _CURRENT.set(call)
+
+
+def leave(token: Any) -> None:
+    """Restore the context that was current before :func:`enter`."""
+    _CURRENT.reset(token)

{mammoth_cli-2.0.43 → mammoth_cli-2.0.44}/mammoth_cli/runtime/executor.py

@@ -18,9 +18,10 @@ import typer
 
 from mammoth_cli.errors.envelope import EXIT_USAGE, CliError
 from mammoth_cli.output.envelope import Meta, Result
+from mammoth_cli.output.normalize import normalize
 from mammoth_cli.output.policy import MACHINE_OUTPUTS, VALID_OUTPUTS
 from mammoth_cli.output.render import render
-from mammoth_cli.runtime import updates
+from mammoth_cli.runtime import embedded, updates
 from mammoth_cli.runtime.invocation import Invocation
 from mammoth_cli.runtime.runlog import RunLog
 from mammoth_cli.services.mapping import map_sdk_exception
@@ -98,6 +99,8 @@ def emit_success(
         update_available=update_available,
     )
     envelope = Result(data=data, meta=meta).to_envelope()
+    if embedded.capture(normalize(envelope)):
+        return
     render(envelope, output=output)
 
 
@@ -113,6 +116,8 @@ def emit_error(error: CliError, *, machine: bool, output: str = "json") -> None:
         output: The selected machine mode. Only ``ndjson`` selects lifecycle
             framing; all other machine errors retain the JSON envelope.
     """
+    if embedded.capture(normalize(error.to_envelope())):
+        return
     if machine:
         render(
             error.to_envelope(),
@@ -237,7 +242,7 @@ def _sync_skill_installs(command_id: str, output: str) -> None:
 
 def _open_run_log(command_id: str, invocation: Invocation | None) -> RunLog | None:
     """Open the run log for ``invocation``; never let logging break a command."""
-    if invocation is None:
+    if invocation is None or embedded.active():
         return None
     try:
         return RunLog.start(

{mammoth_cli-2.0.43 → mammoth_cli-2.0.44}/mammoth_cli/runtime/session.py

@@ -21,6 +21,7 @@ from mammoth_cli.context.resolver import ResolvedAuth, resolve_auth, resolve_pro
 from mammoth_cli.errors.envelope import missing_project_error
 from mammoth_cli.manifest.loader import command_by_id
 from mammoth_cli.output.policy import resolve_policy
+from mammoth_cli.runtime import embedded
 from mammoth_cli.runtime.invocation import Invocation
 from mammoth_cli.services import factory
 from mammoth_cli.services.protocol import MammothService
@@ -101,6 +102,10 @@ def resolved_project(invocation: Invocation) -> int | None:
     Returns:
         The resolved project id, or None when none is set.
     """
+    if embedded.active():
+        # An embedded call has no profile: the host's saved profiles belong to
+        # the host's OS user, not to the user the call runs for.
+        return invocation.project
     profile_name = invocation.profile or profiles.get_selected()
     return resolve_project(invocation, profiles.get_profile(profile_name))
 

{mammoth_cli-2.0.43 → mammoth_cli-2.0.44}/mammoth_cli/runtime/updates.py

@@ -33,6 +33,7 @@ from typing import Any
 import platformdirs
 
 from mammoth_cli import __version__
+from mammoth_cli.runtime import embedded
 
 DISABLE_ENV = "MAMMOTH_NO_UPDATE_CHECK"
 AUTO_UPGRADE_ENV = "MAMMOTH_AUTO_UPGRADE"
@@ -60,8 +61,8 @@ def _flag(name: str) -> bool:
 
 
 def enabled() -> bool:
-    """Whether the check runs at all (``MAMMOTH_NO_UPDATE_CHECK`` unset)."""
-    return not _flag(DISABLE_ENV)
+    """Whether the check runs at all (``MAMMOTH_NO_UPDATE_CHECK`` unset, not embedded)."""
+    return not _flag(DISABLE_ENV) and not embedded.active()
 
 
 def auto_upgrade_enabled() -> bool:

{mammoth_cli-2.0.43 → mammoth_cli-2.0.44}/mammoth_cli/services/sdk_service.py

@@ -115,6 +115,10 @@ class SdkMammothService:
             base_url=auth.base_url,
             **kwargs,
         )
+        if auth.headers:
+            # After construction: the client sets its credential headers in
+            # ``__init__``, and a forwarded session must replace them.
+            self._client.session.headers.update(auth.headers)
         if project_id is not None:
             self._client.set_project_id(project_id)
 

{mammoth_cli-2.0.43 → mammoth_cli-2.0.44}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mammoth-cli"
-version = "2.0.43"
+version = "2.0.44"
 description = "Command-line interface for the Mammoth Analytics platform"
 authors = [{name = "Mammoth Analytics", email = "support@mammoth.io"}]
 readme = "README.md"