mammoth-cli 2.2.70__tar.gz → 2.2.71__tar.gz

{mammoth_cli-2.2.70 → mammoth_cli-2.2.71}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mammoth-cli
-Version: 2.2.70
+Version: 2.2.71
 Summary: Command-line interface for the Mammoth Analytics platform
 Project-URL: homepage, https://mammoth.io
 Project-URL: repository, https://github.com/EdgeMetric/mammothsdk
@@ -17,7 +17,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: <3.15,>=3.12
 Requires-Dist: jsonschema>=4.20
 Requires-Dist: keyring<26,>=25.7
-Requires-Dist: mammoth-io<0.9,>=0.8.32
+Requires-Dist: mammoth-io<0.9,>=0.8.33
 Requires-Dist: platformdirs<5,>=4.10
 Requires-Dist: pydantic<3,>=2.12.5
 Requires-Dist: pyyaml<7,>=6
@@ -242,10 +242,11 @@ mammoth skill install --input '{"agents": ["codex"], "scope": "project"}'
 Use `mammoth skill update` after a CLI upgrade. It refreshes copies owned by the
 installer and reports modified copies instead of silently replacing them.
 
-The CLI checks PyPI for a newer release at most once a day, after a command
+The CLI checks PyPI for a newer release at most once an hour, after a command
 has finished: every JSON envelope carries `meta.update_available` and human
-output adds one stderr line. Set `MAMMOTH_NO_UPDATE_CHECK=1` to turn it off,
-or `MAMMOTH_AUTO_UPGRADE=1` to have it upgrade itself (opt-in; see
+output adds one stderr line. In a terminal it also upgrades itself before the
+next command; set `MAMMOTH_AUTO_UPGRADE=0` to stop that, or
+`MAMMOTH_NO_UPDATE_CHECK=1` to turn the check off (see
 [Upgrade](https://github.com/EdgeMetric/mammothsdk/blob/main/mammoth-cli/docs/upgrade.md)).
 
 ## What you can do

{mammoth_cli-2.2.70 → mammoth_cli-2.2.71}/README.md

@@ -214,10 +214,11 @@ mammoth skill install --input '{"agents": ["codex"], "scope": "project"}'
 Use `mammoth skill update` after a CLI upgrade. It refreshes copies owned by the
 installer and reports modified copies instead of silently replacing them.
 
-The CLI checks PyPI for a newer release at most once a day, after a command
+The CLI checks PyPI for a newer release at most once an hour, after a command
 has finished: every JSON envelope carries `meta.update_available` and human
-output adds one stderr line. Set `MAMMOTH_NO_UPDATE_CHECK=1` to turn it off,
-or `MAMMOTH_AUTO_UPGRADE=1` to have it upgrade itself (opt-in; see
+output adds one stderr line. In a terminal it also upgrades itself before the
+next command; set `MAMMOTH_AUTO_UPGRADE=0` to stop that, or
+`MAMMOTH_NO_UPDATE_CHECK=1` to turn the check off (see
 [Upgrade](https://github.com/EdgeMetric/mammothsdk/blob/main/mammoth-cli/docs/upgrade.md)).
 
 ## What you can do

{mammoth_cli-2.2.70 → mammoth_cli-2.2.71}/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.2.70"
+__version__ = "2.2.71"
 
 # The versioned machine output envelope contract.
 SCHEMA_VERSION = 1

{mammoth_cli-2.2.70 → mammoth_cli-2.2.71}/mammoth_cli/commands/upgrade.py

@@ -278,6 +278,22 @@ def run_upgrade(command: list[str]) -> subprocess.CompletedProcess[str]:
         ) from exc
 
 
+def installed_version() -> str | None:
+    """The version a fresh interpreter reports, i.e. what the upgrade really installed."""
+    try:
+        result = subprocess.run(  # noqa: S603 - fixed argv, no shell
+            [sys.executable, "-m", "mammoth_cli", "--version"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+            check=False,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    output = result.stdout.strip().splitlines()
+    return output[-1].strip() if result.returncode == 0 and output else None
+
+
 def _envelope(
     *,
     manager: str,
@@ -379,17 +395,16 @@ def perform(invocation: Invocation, *, check: bool, target_version: str | None)
             },
             hint=f"Run it manually to see full output: {' '.join(command)}",
         )
-    return (
-        _envelope(
-            manager=manager,
-            current=current,
-            latest=latest,
-            target=target_version,
-            action=ACTION_UPGRADED,
-            command=command,
-        ),
-        {},
+    envelope = _envelope(
+        manager=manager,
+        current=current,
+        latest=latest,
+        target=target_version,
+        action=ACTION_UPGRADED,
+        command=command,
     )
+    envelope["installed_version"] = installed_version()
+    return envelope, {}
 
 
 def upgrade_command(

{mammoth_cli-2.2.70 → mammoth_cli-2.2.71}/mammoth_cli/context/oauth.py

@@ -20,6 +20,7 @@ from __future__ import annotations
 
 import base64
 import contextlib
+import functools
 import hashlib
 import html
 import http.server
@@ -34,13 +35,16 @@ from dataclasses import dataclass
 
 from mammoth_cli.context import credentials
 from mammoth_cli.context.credentials import OAuthSession
-from mammoth_cli.context.endpoint import DEFAULT_SERVER_PREFIX
+from mammoth_cli.context.endpoint import DEFAULT_SERVER_PREFIX, resolve_base_url
 from mammoth_cli.context.profiles import config_dir
 from mammoth_cli.errors.envelope import EXIT_AUTH, EXIT_USAGE, CliError
 
 #: The first-party CLI's OAuth client id, one constant per environment (the
 #: server prefix). The server allow-lists these ids, so they are not
 #: configurable at run time. An environment absent here has no CLI client yet.
+#: This table is the fallback for servers that do not publish
+#: ``mammoth_cli_client_id`` in their OAuth metadata (see
+#: :func:`published_client_id`); it is removed once every server publishes it.
 OAUTH_CLIENT_IDS: dict[str, str] = {
     "challenger": "oc_aea5c2ce829da3f8",
     "koyal": "oc_f2566336e235795c",
@@ -78,11 +82,43 @@ def login_expired_error() -> CliError:
     )
 
 
+#: The metadata field carrying the CLI's client id on servers that publish it.
+METADATA_CLIENT_ID_FIELD = "mammoth_cli_client_id"
+
+
+@functools.cache
+def published_client_id(prefix: str) -> str | None:
+    """The client id the server publishes in its OAuth metadata, or None.
+
+    One GET per environment per process. None when the field is absent, the
+    server cannot be reached, or it answers anything but metadata: the caller
+    then falls back to :data:`OAUTH_CLIENT_IDS`.
+    """
+    from mammoth import oauth as sdk_oauth
+
+    try:
+        status, body = sdk_oauth.metadata_request(resolve_base_url(prefix))
+    except CliError:
+        return None
+    except sdk_oauth.OAuthTransportError:
+        return None
+    if status != 200:
+        return None
+    value = body.get(METADATA_CLIENT_ID_FIELD) if isinstance(body, dict) else None
+    return value if isinstance(value, str) and value else None
+
+
+def _resolve_client_id(server_prefix: str | None) -> str | None:
+    prefix = server_prefix if server_prefix is not None else DEFAULT_SERVER_PREFIX
+    return published_client_id(prefix) or OAUTH_CLIENT_IDS.get(prefix)
+
+
 def has_client_id(server_prefix: str | None) -> bool:
-    """Whether the CLI has an OAuth client registered for this environment."""
-    return (
-        server_prefix if server_prefix is not None else DEFAULT_SERVER_PREFIX
-    ) in OAUTH_CLIENT_IDS
+    """Whether the CLI has an OAuth client for this environment.
+
+    Makes a network call (cached per process): call it only on login paths.
+    """
+    return _resolve_client_id(server_prefix) is not None
 
 
 def client_id_for(server_prefix: str | None) -> str:
@@ -91,17 +127,17 @@ def client_id_for(server_prefix: str | None) -> str:
     Raises:
         CliError: ``oauth_unavailable`` when the environment has no CLI client.
     """
+    client_id = _resolve_client_id(server_prefix)
+    if client_id is not None:
+        return client_id
     prefix = server_prefix if server_prefix is not None else DEFAULT_SERVER_PREFIX
-    try:
-        return OAUTH_CLIENT_IDS[prefix]
-    except KeyError:
-        raise CliError(
-            code=CODE_OAUTH_UNAVAILABLE,
-            message=f"Browser sign-in is not available on '{prefix}' yet.",
-            exit_status=EXIT_USAGE,
-            hint="Pick option 3 (paste an API token) or run: mammoth auth login --method token",
-            recovery_commands=["mammoth auth login --method token"],
-        ) from None
+    raise CliError(
+        code=CODE_OAUTH_UNAVAILABLE,
+        message=f"Browser sign-in is not available on '{prefix}' yet.",
+        exit_status=EXIT_USAGE,
+        hint="Pick option 3 (paste an API token) or run: mammoth auth login --method token",
+        recovery_commands=["mammoth auth login --method token"],
+    )
 
 
 # --- PKCE ---------------------------------------------------------------------

{mammoth_cli-2.2.70 → mammoth_cli-2.2.71}/mammoth_cli/runtime/updates.py

@@ -1,8 +1,8 @@
-"""Once-a-day update check, and the opt-in automatic upgrade.
+"""Hourly update check, and the automatic upgrade (on by default).
 
 The CLI never blocks a command on the network for this. A command reads the
 cached answer (``update-check.json`` in the platform state directory, next to
-the run log's ``logs/``) and, when that answer is older than a day, refreshes
+the run log's ``logs/``) and, when that answer is older than an hour, refreshes
 it *after* its own output has been written, with a short timeout and every
 failure swallowed. The hint therefore appears from the next command on.
 
@@ -12,11 +12,13 @@ What a caller sees:
   ``{"current", "latest", "command"}`` when a newer release is on PyPI.
 * one line on stderr in human output modes (never in ``json``/``ndjson``).
 * ``MAMMOTH_NO_UPDATE_CHECK=1`` disables the check and the hint entirely.
-* ``MAMMOTH_AUTO_UPGRADE=1`` performs the upgrade before the command runs,
-  once per detected release, through the same manager detection as
-  ``mammoth upgrade``; the running command still completes on the version
-  that started it. It is opt-in because pinned environments (locks, CI,
-  shared venvs) must never change underneath a task.
+* The upgrade runs before the command, once per detected release, through the
+  same manager detection as ``mammoth upgrade``; the running command still
+  completes on the version that started it. ``MAMMOTH_AUTO_UPGRADE=0`` (or
+  ``false``/``no``/``off``) turns it off. Unless ``MAMMOTH_AUTO_UPGRADE`` is
+  set to an on value (``1``), it also stays off when stdout is not a terminal
+  or ``CI`` is set, because pinned environments (locks, CI, scripts) must
+  never change underneath a task.
 
 ``MAMMOTH_UPDATE_CACHE`` overrides the cache file path (tests and sandboxes).
 """
@@ -41,7 +43,7 @@ AUTO_UPGRADE_ENV = "MAMMOTH_AUTO_UPGRADE"
 CACHE_ENV = "MAMMOTH_UPDATE_CACHE"
 
 #: How long a cached PyPI answer is trusted.
-CACHE_TTL = _dt.timedelta(hours=24)
+CACHE_TTL = _dt.timedelta(hours=1)
 #: The background refresh must not hold a finished command hostage.
 REFRESH_TIMEOUT_SECONDS = 3.0
 #: Commands that manage the install themselves; no hint, no auto-upgrade.
@@ -55,6 +57,7 @@ _NO_NOTICE = frozenset({"upgrade"})
 UPGRADE_COMMAND = "mammoth upgrade --yes"
 
 _TRUTHY = frozenset({"1", "true", "yes", "on"})
+_FALSY = frozenset({"0", "false", "no", "off"})
 
 
 def _flag(name: str) -> bool:
@@ -66,8 +69,23 @@ def enabled() -> bool:
     return not _flag(DISABLE_ENV) and not embedded.active()
 
 
+def _interactive_session() -> bool:
+    """A terminal on stdout and no ``CI`` variable: a person is running this."""
+    return sys.stdout.isatty() and not (os.environ.get("CI") or "").strip()
+
+
 def auto_upgrade_enabled() -> bool:
-    return enabled() and _flag(AUTO_UPGRADE_ENV)
+    """On by default for interactive sessions; ``MAMMOTH_AUTO_UPGRADE`` overrides.
+
+    ``0``/``false``/``no``/``off`` turns it off; ``1``/``true``/``yes``/``on``
+    forces it on even without a terminal or inside CI.
+    """
+    if not enabled():
+        return False
+    setting = (os.environ.get(AUTO_UPGRADE_ENV) or "").strip().lower()
+    if setting in _FALSY:
+        return False
+    return setting in _TRUTHY or _interactive_session()
 
 
 def cache_path() -> Path:
@@ -153,10 +171,13 @@ def available_update(command_id: str | None = None) -> dict[str, Any] | None:
 
 
 def hint_line(update: dict[str, Any]) -> str:
-    return (
+    line = (
         f"mammoth-cli {update['latest']} is available (you have {update['current']}); "
         f"run: {update['command']}"
     )
+    if auto_upgrade_enabled():
+        line += f" (auto-upgrade is on; turn it off with {AUTO_UPGRADE_ENV}=0)"
+    return line
 
 
 def _fetch_latest() -> str | None:
@@ -206,7 +227,7 @@ def refresh_in_background(command_id: str | None = None) -> None:
     """Refresh a stale cache in a detached process, so the command exits at once.
 
     :func:`refresh_if_stale` asks PyPI with a 3 s timeout; run inline it keeps
-    the finished command alive for up to that long once a day. The cache is
+    the finished command alive for up to that long once an hour. The cache is
     stamped first so concurrent commands do not each spawn a check; the child
     (``python -m mammoth_cli.runtime.updates``) writes the answer.
     """
@@ -241,7 +262,7 @@ def emit_hint(update: dict[str, Any] | None, *, output: str) -> None:
 
 
 def auto_upgrade(command_id: str, run_log: Any = None) -> dict[str, Any] | None:
-    """Upgrade in place when ``MAMMOTH_AUTO_UPGRADE`` is set and a release is cached.
+    """Upgrade in place when auto-upgrade is enabled and a release is cached.
 
     Returns a record of what happened (also written to ``run_log`` when
     given), or ``None`` when nothing was attempted. The current process keeps

{mammoth_cli-2.2.70 → mammoth_cli-2.2.71}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "mammoth-cli"
-version = "2.2.70"
+version = "2.2.71"
 description = "Command-line interface for the Mammoth Analytics platform"
 authors = [{name = "Mammoth Analytics", email = "support@mammoth.io"}]
 readme = "README.md"
 license = "LicenseRef-Proprietary"
 requires-python = ">=3.12,<3.15"
 dependencies = [
-    "mammoth-io (>=0.8.32,<0.9)",
+    "mammoth-io (>=0.8.33,<0.9)",
     "typer (>=0.27,<0.28)",
     "rich (>=15,<16)",
     "platformdirs (>=4.10,<5)",