datex-studio-cli 0.4.4__tar.gz → 0.4.5__tar.gz

{datex_studio_cli-0.4.4 → datex_studio_cli-0.4.5}/PKG-INFO

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

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

{datex_studio_cli-0.4.4 → datex_studio_cli-0.4.5}/src/dxs/__init__.py

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

{datex_studio_cli-0.4.4 → datex_studio_cli-0.4.5}/src/dxs/cli.py

@@ -507,18 +507,20 @@ def _ctx_extras(dxs_ctx: "DxsContext | None") -> dict[str, Any]:
 
 
 @cli.command("update")
-@click.option(
-    "--check",
-    "check_only",
-    is_flag=True,
-    default=False,
-    help="Print whether an update is available without prompting to install",
-)
-def update_cmd(check_only: bool) -> None:
-    """Check PyPI for a newer release and optionally upgrade in place."""
+def update_cmd() -> None:
+    """Check PyPI for a newer release and print the upgrade command.
+
+    This command never performs the upgrade itself — run the printed
+    command in a fresh shell. This avoids the running-binary file-lock
+    issues that any in-process upgrade hits on Windows.
+    """
+    import time
+
     from dxs.utils.update_check import (
+        PACKAGE_NAME,
         _fetch_latest_version,
-        _run_upgrade,
+        _read_cache,
+        _write_cache,
         detect_upgrade_command,
         is_newer,
     )
@@ -536,12 +538,19 @@ def update_cmd(check_only: bool) -> None:
         return
 
     upgrade_cmd = detect_upgrade_command()
-    click.echo(f"Upgrade command: {upgrade_cmd}", err=True)
-    if check_only:
-        return
-
-    if click.confirm("Upgrade now?", default=True, err=True):
-        sys.exit(_run_upgrade(upgrade_cmd))
+    click.echo("", err=True)
+    click.echo(f"  A new release of dxs is available: {__version__} → {latest}", err=True)
+    click.echo(f"  To upgrade, run: {upgrade_cmd}", err=True)
+    click.echo(f"  https://pypi.org/project/{PACKAGE_NAME}/{latest}/", err=True)
+
+    # Refresh the cache and suppress the auto-banner for the next dedupe
+    # window — the user has explicitly seen the news.
+    now = time.time()
+    cache = _read_cache() or {}
+    cache["latest"] = latest
+    cache["checked_at"] = now
+    cache["last_notified_at"] = now
+    _write_cache(cache)
 
 
 # Register commands when module loads

datex_studio_cli-0.4.5/src/dxs/utils/update_check.py

@@ -0,0 +1,208 @@
+"""PyPI update notifier.
+
+After each command, if the on-disk cache says a newer version exists on
+PyPI, print a one-time banner to stderr telling the user how to upgrade.
+The actual upgrade is the user's responsibility — we never exec, spawn,
+or otherwise touch the running install. This sidesteps every file-lock,
+process-replacement, and platform-specific upgrade problem.
+
+The PyPI fetch happens in a background daemon thread, so a stale cache is
+refreshed for *next* time. The current run never blocks on the network.
+
+Environment / flag controls:
+- ``DXS_NO_UPDATE_CHECK=1`` disables both the check and the banner.
+- ``--no-update-check`` (CLI flag) does the same per-invocation.
+- ``DXS_UPDATE_CHECK_DEBUG=1`` surfaces sender errors (development only).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import sys
+import threading
+import time
+from pathlib import Path
+from typing import Any
+
+import click
+
+from dxs import __version__
+from dxs.utils.paths import get_datex_home
+
+PYPI_URL = "https://pypi.org/pypi/datex-studio-cli/json"
+PACKAGE_NAME = "datex-studio-cli"
+CACHE_TTL_SECONDS = 24 * 60 * 60
+NOTIFY_DEDUPE_SECONDS = 60 * 60  # at most one banner per hour per machine
+HTTP_TIMEOUT_SECONDS = 2.0
+
+_CI_ENV_VARS = ("CI", "CONTINUOUS_INTEGRATION", "GITHUB_ACTIONS", "BUILDKITE", "TF_BUILD")
+
+
+def _cache_path() -> Path:
+    return get_datex_home() / "update_check.json"
+
+
+def _debug(msg: str) -> None:
+    if os.environ.get("DXS_UPDATE_CHECK_DEBUG", "").lower() in ("1", "true", "yes"):
+        click.echo(f"[update-check] {msg}", err=True)
+
+
+def is_disabled() -> bool:
+    """Return True if the update check has been disabled via env var."""
+    return os.environ.get("DXS_NO_UPDATE_CHECK", "").lower() in ("1", "true", "yes")
+
+
+def _is_ci() -> bool:
+    return any(os.environ.get(v) for v in _CI_ENV_VARS)
+
+
+def _read_cache() -> dict[str, Any] | None:
+    path = _cache_path()
+    if not path.exists():
+        return None
+    try:
+        data = json.loads(path.read_text())
+        if isinstance(data, dict):
+            return data
+    except (json.JSONDecodeError, OSError) as e:
+        _debug(f"cache read failed: {e}")
+    return None
+
+
+def _write_cache(data: dict[str, Any]) -> None:
+    try:
+        _cache_path().write_text(json.dumps(data))
+    except OSError as e:
+        _debug(f"cache write failed: {e}")
+
+
+def _fetch_latest_version() -> str | None:
+    """Fetch the latest version from PyPI. Returns None on any failure."""
+    try:
+        import httpx
+
+        response = httpx.get(PYPI_URL, timeout=HTTP_TIMEOUT_SECONDS)
+        response.raise_for_status()
+        latest = response.json()["info"]["version"]
+        return str(latest) if latest else None
+    except Exception as e:  # noqa: BLE001 - never let telemetry break the CLI
+        _debug(f"fetch failed: {e}")
+        return None
+
+
+def _refresh_cache_worker() -> None:
+    latest = _fetch_latest_version()
+    if not latest:
+        return
+    cache = _read_cache() or {}
+    cache["latest"] = latest
+    cache["checked_at"] = time.time()
+    _write_cache(cache)
+
+
+def _maybe_refresh_async(cache: dict[str, Any] | None) -> None:
+    """Spawn a daemon thread to refresh the cache if it's missing or stale."""
+    needs_refresh = (
+        cache is None or (time.time() - float(cache.get("checked_at", 0))) > CACHE_TTL_SECONDS
+    )
+    if not needs_refresh:
+        return
+    thread = threading.Thread(target=_refresh_cache_worker, daemon=True, name="dxs-update-check")
+    thread.start()
+
+
+_VERSION_RE = re.compile(r"^(\d+)(?:\.(\d+))?(?:\.(\d+))?")
+
+
+def _parse_version(v: str) -> tuple[int, int, int]:
+    """Parse an X.Y.Z version into a tuple. Pre-release suffixes are ignored.
+
+    Returns (0, 0, 0) on unparseable input — treated as oldest possible.
+    """
+    m = _VERSION_RE.match(v.strip())
+    if not m:
+        return (0, 0, 0)
+    return (int(m.group(1) or 0), int(m.group(2) or 0), int(m.group(3) or 0))
+
+
+def is_newer(candidate: str, current: str) -> bool:
+    """Return True if `candidate` is a newer version than `current`."""
+    return _parse_version(candidate) > _parse_version(current)
+
+
+def detect_upgrade_command() -> str:
+    """Best-effort detection of how dxs was installed.
+
+    Returns the shell command the user should run to upgrade.
+    """
+    exe = sys.executable
+    # uv tool installs land under ~/.local/share/uv/tools/<pkg>/...
+    if "/uv/tools/" in exe or "\\uv\\tools\\" in exe:
+        return f"uv tool upgrade {PACKAGE_NAME}"
+    # pipx installs land under ~/.local/pipx/venvs/<pkg>/...
+    if "/pipx/" in exe or "\\pipx\\" in exe:
+        return f"pipx upgrade {PACKAGE_NAME}"
+    # Fallback: pip in whatever interpreter the user is on
+    return f"{exe} -m pip install --upgrade {PACKAGE_NAME}"
+
+
+def _stderr_is_tty() -> bool:
+    """True when stderr is attached to a TTY.
+
+    Only stderr matters — the banner is written there. Piping stdout (e.g.
+    ``dxs odata ... | jq``) leaves stderr untouched, so the user still sees
+    the banner in their terminal. Redirecting stderr (``2>log``) suppresses
+    it, as intended.
+    """
+    return sys.stderr.isatty()
+
+
+def _print_banner(latest: str, upgrade_cmd: str) -> None:
+    """Print the update banner to stderr."""
+    click.echo("", err=True)
+    click.echo(
+        f"  A new release of dxs is available: {__version__} → {latest}",
+        err=True,
+    )
+    click.echo(f"  To upgrade, run: {upgrade_cmd}", err=True)
+    click.echo(f"  https://pypi.org/project/{PACKAGE_NAME}/{latest}/", err=True)
+
+
+def maybe_show_update_notice(skip: bool = False) -> None:
+    """If the cache shows a newer version, print a one-time banner to stderr.
+
+    Always returns quickly — the PyPI fetch happens in a background thread
+    that only writes to the cache. The first run on a stale cache prints
+    nothing; the next run sees the refreshed cache and prints the banner.
+    Dedupe keeps it to one banner per ``NOTIFY_DEDUPE_SECONDS`` window so
+    fast-fire commands don't spam.
+
+    Args:
+        skip: If True, skip both the check and any cache refresh. Used to
+            honor ``--no-update-check``.
+    """
+    if skip or is_disabled() or _is_ci():
+        return
+    if not _stderr_is_tty():
+        return
+
+    cache = _read_cache()
+    _maybe_refresh_async(cache)
+
+    if not cache:
+        return
+
+    latest = cache.get("latest")
+    if not isinstance(latest, str) or not is_newer(latest, __version__):
+        return
+
+    last_notified = float(cache.get("last_notified_at", 0))
+    if time.time() - last_notified < NOTIFY_DEDUPE_SECONDS:
+        return
+
+    _print_banner(latest, detect_upgrade_command())
+
+    cache["last_notified_at"] = time.time()
+    _write_cache(cache)

datex_studio_cli-0.4.4/src/dxs/utils/update_check.py

@@ -1,310 +0,0 @@
-"""PyPI update check.
-
-On each invocation, reads a cached "latest version on PyPI" entry. If a newer
-version is available and we're attached to an interactive terminal, prints a
-banner and offers to upgrade in place. The PyPI fetch happens in a background
-daemon thread so the user's command is never delayed.
-
-Environment / flag controls:
-- ``DXS_NO_UPDATE_CHECK=1`` disables both the check and the banner.
-- ``--no-update-check`` (CLI flag) does the same per-invocation.
-- ``DXS_UPDATE_CHECK_DEBUG=1`` surfaces sender errors (development only).
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import platform
-import re
-import shlex
-import subprocess
-import sys
-import tempfile
-import threading
-import time
-from pathlib import Path
-from typing import Any
-
-import click
-
-from dxs import __version__
-from dxs.utils.paths import get_datex_home
-
-PYPI_URL = "https://pypi.org/pypi/datex-studio-cli/json"
-PACKAGE_NAME = "datex-studio-cli"
-CACHE_TTL_SECONDS = 24 * 60 * 60
-PROMPT_DEDUPE_SECONDS = 60 * 60  # at most one prompt per hour per machine
-HTTP_TIMEOUT_SECONDS = 2.0
-
-_CI_ENV_VARS = ("CI", "CONTINUOUS_INTEGRATION", "GITHUB_ACTIONS", "BUILDKITE", "TF_BUILD")
-
-
-def _cache_path() -> Path:
-    return get_datex_home() / "update_check.json"
-
-
-def _debug(msg: str) -> None:
-    if os.environ.get("DXS_UPDATE_CHECK_DEBUG", "").lower() in ("1", "true", "yes"):
-        click.echo(f"[update-check] {msg}", err=True)
-
-
-def is_disabled() -> bool:
-    """Return True if the update check has been disabled via env var."""
-    return os.environ.get("DXS_NO_UPDATE_CHECK", "").lower() in ("1", "true", "yes")
-
-
-def _is_ci() -> bool:
-    return any(os.environ.get(v) for v in _CI_ENV_VARS)
-
-
-def _read_cache() -> dict[str, Any] | None:
-    path = _cache_path()
-    if not path.exists():
-        return None
-    try:
-        data = json.loads(path.read_text())
-        if isinstance(data, dict):
-            return data
-    except (json.JSONDecodeError, OSError) as e:
-        _debug(f"cache read failed: {e}")
-    return None
-
-
-def _write_cache(data: dict[str, Any]) -> None:
-    try:
-        _cache_path().write_text(json.dumps(data))
-    except OSError as e:
-        _debug(f"cache write failed: {e}")
-
-
-def _fetch_latest_version() -> str | None:
-    """Fetch the latest version from PyPI. Returns None on any failure."""
-    try:
-        import httpx
-
-        response = httpx.get(PYPI_URL, timeout=HTTP_TIMEOUT_SECONDS)
-        response.raise_for_status()
-        latest = response.json()["info"]["version"]
-        return str(latest) if latest else None
-    except Exception as e:  # noqa: BLE001 - never let telemetry break the CLI
-        _debug(f"fetch failed: {e}")
-        return None
-
-
-def _refresh_cache_worker() -> None:
-    latest = _fetch_latest_version()
-    if not latest:
-        return
-    cache = _read_cache() or {}
-    cache["latest"] = latest
-    cache["checked_at"] = time.time()
-    _write_cache(cache)
-
-
-def _maybe_refresh_async(cache: dict[str, Any] | None) -> None:
-    """Spawn a daemon thread to refresh the cache if it's missing or stale."""
-    needs_refresh = (
-        cache is None or (time.time() - float(cache.get("checked_at", 0))) > CACHE_TTL_SECONDS
-    )
-    if not needs_refresh:
-        return
-    thread = threading.Thread(target=_refresh_cache_worker, daemon=True, name="dxs-update-check")
-    thread.start()
-
-
-_VERSION_RE = re.compile(r"^(\d+)(?:\.(\d+))?(?:\.(\d+))?")
-
-
-def _parse_version(v: str) -> tuple[int, int, int]:
-    """Parse an X.Y.Z version into a tuple. Pre-release suffixes are ignored.
-
-    Returns (0, 0, 0) on unparseable input — treated as oldest possible.
-    """
-    m = _VERSION_RE.match(v.strip())
-    if not m:
-        return (0, 0, 0)
-    return (int(m.group(1) or 0), int(m.group(2) or 0), int(m.group(3) or 0))
-
-
-def is_newer(candidate: str, current: str) -> bool:
-    """Return True if `candidate` is a newer version than `current`."""
-    return _parse_version(candidate) > _parse_version(current)
-
-
-def detect_upgrade_command() -> str:
-    """Best-effort detection of how dxs was installed.
-
-    Returns the shell command the user should run to upgrade.
-    """
-    exe = sys.executable
-    # uv tool installs land under ~/.local/share/uv/tools/<pkg>/...
-    if "/uv/tools/" in exe or "\\uv\\tools\\" in exe:
-        return f"uv tool upgrade {PACKAGE_NAME}"
-    # pipx installs land under ~/.local/pipx/venvs/<pkg>/...
-    if "/pipx/" in exe or "\\pipx\\" in exe:
-        return f"pipx upgrade {PACKAGE_NAME}"
-    # Fallback: pip in whatever interpreter the user is on
-    return f"{exe} -m pip install --upgrade {PACKAGE_NAME}"
-
-
-def _run_upgrade(command: str) -> int:
-    """Hand off to the upgrade command, tearing down this process first.
-
-    POSIX uses ``os.execvp``, which truly replaces the process image and
-    frees all file handles before the upgrader (uv/pipx/pip) starts rewriting
-    the venv.
-
-    Windows is different: ``os.execvp`` there spawns a child and exits, but
-    Windows holds an exclusive image-file lock on the running ``dxs.exe``
-    launcher (e.g. ``~/.local/bin/dxs.exe``) until the launcher process fully
-    terminates — uv races ahead and fails to overwrite the entry-point shim
-    with "os error 32: file in use". So on Windows we write a small batch
-    helper that waits briefly for the launcher to exit, then runs the
-    upgrade in a fresh console window, and we exit immediately to release
-    the lock.
-
-    On success this function does not return. Returns 1 only when the
-    upgrade fails to start.
-    """
-    command = command.strip()
-    if not command:
-        click.echo("Upgrade command was empty.", err=True)
-        return 1
-
-    click.echo(f"Running: {command}", err=True)
-    try:
-        sys.stdout.flush()
-        sys.stderr.flush()
-    except Exception:  # noqa: BLE001
-        pass
-
-    if platform.system() == "Windows":
-        return _spawn_windows_upgrade(command)
-
-    args = shlex.split(command)
-    try:
-        os.execvp(args[0], args)
-    except OSError as e:
-        click.echo(f"Upgrade failed to start: {e}", err=True)
-        return 1
-    return 1  # unreachable on success
-
-
-def _spawn_windows_upgrade(command: str) -> int:
-    """Spawn the upgrade in a new console window detached from this process.
-
-    Writes a temporary ``.cmd`` file that waits ~3 seconds for ``dxs.exe`` to
-    fully terminate (releasing Windows' image-file lock on the launcher),
-    then runs the upgrade with one short retry if the first attempt still
-    hits a file-in-use error. The current process exits immediately so the
-    lock is released as quickly as possible.
-    """
-    script = (
-        "@echo off\r\n"
-        "echo Waiting for dxs to exit so its files can be replaced...\r\n"
-        # ping -n N sleeps roughly (N-1) seconds; portable across all
-        # Windows versions where `timeout` may not be available.
-        "ping -n 4 127.0.0.1 > nul\r\n"
-        f"echo Running: {command}\r\n"
-        f"{command}\r\n"
-        "if %ERRORLEVEL% NEQ 0 (\r\n"
-        "  echo.\r\n"
-        "  echo First attempt failed; waiting and retrying once...\r\n"
-        "  ping -n 6 127.0.0.1 > nul\r\n"
-        f"  {command}\r\n"
-        ")\r\n"
-        "echo.\r\n"
-        "if %ERRORLEVEL% NEQ 0 (echo Upgrade failed.) else (echo Upgrade complete.)\r\n"
-        "echo.\r\n"
-        "pause\r\n"
-    )
-
-    try:
-        fd, script_path = tempfile.mkstemp(prefix="dxs-upgrade-", suffix=".cmd")
-        with os.fdopen(fd, "w", newline="") as f:
-            f.write(script)
-    except OSError as e:
-        click.echo(f"Failed to write upgrade helper script: {e}", err=True)
-        return 1
-
-    click.echo(
-        "Spawning the upgrade in a new console window so dxs can exit and release its files.",
-        err=True,
-    )
-
-    CREATE_NEW_CONSOLE = 0x00000010
-    try:
-        subprocess.Popen(
-            ["cmd.exe", "/c", script_path],
-            creationflags=CREATE_NEW_CONSOLE,
-            close_fds=True,
-        )
-    except OSError as e:
-        click.echo(f"Failed to spawn upgrade: {e}", err=True)
-        return 1
-
-    sys.exit(0)
-
-
-def _interactive() -> bool:
-    """True only when stdin, stderr, and stdout are all attached to a TTY.
-
-    We require stdout TTY too, because piping/redirecting stdout is the strongest
-    signal that the user is consuming structured output programmatically and
-    won't appreciate a banner mid-stream.
-    """
-    return all(s.isatty() for s in (sys.stdin, sys.stderr, sys.stdout))
-
-
-def maybe_show_update_notice(skip: bool = False) -> None:
-    """Check the cache and, if a newer version is available, prompt to upgrade.
-
-    Always returns quickly — the network fetch happens in a background thread.
-
-    Args:
-        skip: If True, skip both the check and any cache refresh. Used to honor
-            ``--no-update-check``.
-    """
-    if skip or is_disabled() or _is_ci():
-        return
-    if not _interactive():
-        return
-
-    cache = _read_cache()
-    _maybe_refresh_async(cache)
-
-    if not cache:
-        return
-
-    latest = cache.get("latest")
-    if not isinstance(latest, str) or not is_newer(latest, __version__):
-        return
-
-    last_prompted = float(cache.get("last_prompted_at", 0))
-    if time.time() - last_prompted < PROMPT_DEDUPE_SECONDS:
-        return
-
-    upgrade_cmd = detect_upgrade_command()
-    click.echo("", err=True)
-    click.echo(
-        f"  dxs {latest} is available (you have {__version__})",
-        err=True,
-    )
-    click.echo(f"  Upgrade command: {upgrade_cmd}", err=True)
-
-    cache["last_prompted_at"] = time.time()
-    _write_cache(cache)
-
-    try:
-        if click.confirm("  Upgrade now?", default=False, err=True):
-            click.echo(
-                "  After upgrade completes, re-run your dxs command to use the new version.",
-                err=True,
-            )
-            exit_code = _run_upgrade(upgrade_cmd)
-            # _run_upgrade only returns when the upgrade failed to start.
-            click.echo(f"  Upgrade failed to start (code {exit_code}).", err=True)
-    except (click.Abort, EOFError):
-        click.echo("", err=True)
-        return