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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mammoth-cli
-Version: 2.2.70
+Version: 2.2.72
 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.72}/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.72}/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.72"
 
 # The versioned machine output envelope contract.
 SCHEMA_VERSION = 1

{mammoth_cli-2.2.70 → mammoth_cli-2.2.72}/mammoth_cli/commands/auth.py

@@ -23,7 +23,7 @@ import typer
 from pydantic import ValidationError
 
 from mammoth_cli.context import credentials, oauth, profiles, resolver
-from mammoth_cli.context.endpoint import DEFAULT_SERVER_PREFIX, resolve_base_url
+from mammoth_cli.context.endpoint import resolve_base_url
 from mammoth_cli.context.resolver import ResolvedAuth, resolve_auth
 from mammoth_cli.contracts.auth import LoginRequest
 from mammoth_cli.errors.envelope import (
@@ -306,13 +306,9 @@ def _choose_method(
         return method
     if invocation.input_file is not None or blockers:
         return "token"
-    available = oauth.has_client_id(server_prefix)
-    prefix = server_prefix if server_prefix is not None else DEFAULT_SERVER_PREFIX
-    browser_note = "recommended" if available else f"(not yet available on {prefix})"
-    device_note = "no browser on this machine" if available else browser_note
     typer.echo("How do you want to sign in?", err=True)
-    typer.echo(f"  1) Browser (OAuth)      {browser_note}", err=True)
-    typer.echo(f"  2) Device code          {device_note}", err=True)
+    typer.echo("  1) Browser (OAuth)      recommended", err=True)
+    typer.echo("  2) Device code          no browser on this machine", err=True)
     typer.echo("  3) Paste an API token   for CI and scripts", err=True)
     if sys.stdin.isatty():
         return _choose_by_keypress()

{mammoth_cli-2.2.70 → mammoth_cli-2.2.72}/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.72}/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,18 +35,14 @@ 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
+from mammoth_cli.errors.envelope import EXIT_AUTH, 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.
-OAUTH_CLIENT_IDS: dict[str, str] = {
-    "challenger": "oc_aea5c2ce829da3f8",
-    "koyal": "oc_f2566336e235795c",
-    "app": "oc_b559f85cfb4de34c",
-}
+#: The first-party CLI's OAuth client id: the same in every environment. The
+#: server publishes it in its OAuth metadata (see :func:`published_client_id`);
+#: this is the id used when it publishes nothing.
+BUILTIN_CLIENT_ID = "mammoth-cli"
 
 #: Refresh when the access token has less than this long to live.
 REFRESH_MARGIN_SECONDS = 120
@@ -55,7 +52,6 @@ _LOCK_POLL_SECONDS = 0.1
 _LOCK_WAIT_SECONDS = 60.0
 
 CODE_LOGIN_EXPIRED = "login_expired"
-CODE_OAUTH_UNAVAILABLE = "oauth_unavailable"
 CODE_OAUTH_LOGIN_FAILED = "oauth_login_failed"
 CODE_DEVICE_LOGIN_EXPIRED = "device_login_expired"
 
@@ -78,30 +74,36 @@ def login_expired_error() -> CliError:
     )
 
 
-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
+#: The metadata field carrying the CLI's client id on servers that publish it.
+METADATA_CLIENT_ID_FIELD = "mammoth_cli_client_id"
 
 
-def client_id_for(server_prefix: str | None) -> str:
-    """Return the CLI's OAuth client id for one environment.
+@functools.cache
+def published_client_id(prefix: str) -> str | None:
+    """The client id the server publishes in its OAuth metadata, or None.
 
-    Raises:
-        CliError: ``oauth_unavailable`` when the environment has no CLI client.
+    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 uses :data:`BUILTIN_CLIENT_ID`.
     """
-    prefix = server_prefix if server_prefix is not None else DEFAULT_SERVER_PREFIX
+    from mammoth import oauth as sdk_oauth
+
     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
+        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 client_id_for(server_prefix: str | None) -> str:
+    """Return the CLI's OAuth client id: the published one, else the built-in one."""
+    prefix = server_prefix if server_prefix is not None else DEFAULT_SERVER_PREFIX
+    return published_client_id(prefix) or BUILTIN_CLIENT_ID
 
 
 # --- PKCE ---------------------------------------------------------------------

{mammoth_cli-2.2.70 → mammoth_cli-2.2.72}/mammoth_cli/errors/envelope.py

@@ -161,7 +161,6 @@ ERROR_SUMMARIES: dict[str, str] = {
     "not_authenticated": _S_SIGN_IN,
     "not_implemented": _S_UNAVAILABLE,
     "oauth_login_failed": "The browser sign-in didn't complete.",
-    "oauth_unavailable": "Browser sign-in isn't available on this server.",
     "oauth_grant_revoke_failed": "The server did not revoke this sign-in grant.",
     "outcome_unknown": "It isn't clear whether this step went through. Check before trying again.",
     "pipeline_changed": "The pipeline was changed by someone else while this step ran.",

{mammoth_cli-2.2.70 → mammoth_cli-2.2.72}/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.72}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "mammoth-cli"
-version = "2.2.70"
+version = "2.2.72"
 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)",