gumloop 0.4.2__tar.gz → 0.4.4__tar.gz

gumloop-0.4.4/.github/workflows/release.yml

@@ -0,0 +1,46 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write # PyPI trusted publishing
+      contents: write # create the GitHub Release
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
+
+      - uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
+
+      - name: Verify tag matches package version
+        run: |
+          version="$(uvx hatchling version)"
+          if [ "v${version}" != "${GITHUB_REF_NAME}" ]; then
+            echo "Tag ${GITHUB_REF_NAME} does not match package version ${version}" >&2
+            exit 1
+          fi
+
+      - name: Build
+        run: uv build
+
+      # --check-url skips files already on PyPI so the job is safe to rerun
+      # if a later step fails.
+      - name: Publish to PyPI
+        run: uv publish --trusted-publishing always --check-url https://pypi.org/simple/
+
+      # A tag created via the Releases UI already has a release; just attach
+      # the artifacts to it.
+      - name: Create GitHub Release
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          if gh release view "${GITHUB_REF_NAME}" >/dev/null 2>&1; then
+            gh release upload "${GITHUB_REF_NAME}" dist/* --clobber
+          else
+            gh release create "${GITHUB_REF_NAME}" dist/* --generate-notes --verify-tag
+          fi

{gumloop-0.4.2 → gumloop-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gumloop
-Version: 0.4.2
+Version: 0.4.4
 Summary: Python client for the Gumloop API
 Project-URL: Homepage, https://github.com/gumloop/gumloop-py
 Project-URL: Bug Tracker, https://github.com/gumloop/gumloop-py/issues
@@ -25,12 +25,28 @@ Description-Content-Type: text/markdown
 
 # Gumloop Python Client
 
-A Python client for the Gumloop API that makes it easy to run and monitor Gumloop flows.
+A Python client for the Gumloop API that makes it easy to run and monitor Gumloop flows, plus the `gumloop` CLI.
 
-## Installation
+## CLI
+
+Install on macOS or Linux:
+
+```bash
+curl -fsSL https://gumloop.com/cli/install.sh | sh
+```
+
+The installer is fully self-contained under `~/.gumloop` — it ships its own Python, never touches your system Python, and needs no sudo. Run `gumloop --help` to get started and update any time with:
+
+```bash
+gumloop update
+```
+
+## SDK
+
+To use the client as a library in your own Python project:
 
 ```bash
-pip install gumloop
+uv add gumloop
 ```
 
 ## Usage

{gumloop-0.4.2 → gumloop-0.4.4}/README.md

@@ -1,11 +1,27 @@
 # Gumloop Python Client
 
-A Python client for the Gumloop API that makes it easy to run and monitor Gumloop flows.
+A Python client for the Gumloop API that makes it easy to run and monitor Gumloop flows, plus the `gumloop` CLI.
 
-## Installation
+## CLI
+
+Install on macOS or Linux:
+
+```bash
+curl -fsSL https://gumloop.com/cli/install.sh | sh
+```
+
+The installer is fully self-contained under `~/.gumloop` — it ships its own Python, never touches your system Python, and needs no sudo. Run `gumloop --help` to get started and update any time with:
+
+```bash
+gumloop update
+```
+
+## SDK
+
+To use the client as a library in your own Python project:
 
 ```bash
-pip install gumloop
+uv add gumloop
 ```
 
 ## Usage

{gumloop-0.4.2 → gumloop-0.4.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "gumloop"
-version = "0.4.2"
+dynamic = ["version"]
 description = "Python client for the Gumloop API"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -32,6 +32,9 @@ dependencies = [
     "typer>=0.25.1",
 ]
 
+[tool.hatch.version]
+path = "src/gumloop/_version.py"
+
 [project.scripts]
 gumloop = "gumloop.cli.main:main"
 

gumloop-0.4.4/scripts/install.sh

@@ -0,0 +1,286 @@
+#!/bin/sh
+# Gumloop CLI installer: curl -fsSL https://gumloop.com/cli/install.sh | sh
+
+set -eu
+
+UV_VERSION="0.11.31"
+PYTHON_VERSION="3.12"
+INSTALLER_VERSION="1"
+
+GUMLOOP_HOME="${GUMLOOP_INSTALL_DIR:-$HOME/.gumloop}"
+VENV_DIR="$GUMLOOP_HOME/venv"
+UV_BIN="$GUMLOOP_HOME/bin/uv"
+SHIM_DIR="$HOME/.local/bin"
+SHIM_PATH="$SHIM_DIR/gumloop"
+
+if [ -t 1 ]; then
+    BOLD="$(printf '\033[1m')"
+    RED="$(printf '\033[31m')"
+    GREEN="$(printf '\033[32m')"
+    YELLOW="$(printf '\033[33m')"
+    RESET="$(printf '\033[0m')"
+else
+    BOLD="" RED="" GREEN="" YELLOW="" RESET=""
+fi
+
+step() {
+    printf '%s==>%s %s\n' "${BOLD}" "${RESET}" "$1"
+}
+
+warn() {
+    printf '%swarning:%s %s\n' "${YELLOW}" "${RESET}" "$1" >&2
+}
+
+fail() {
+    printf '%serror:%s %s\n' "${RED}" "${RESET}" "$1" >&2
+    exit 1
+}
+
+# [ -r /dev/tty ] passes in CI/containers where the open still fails.
+has_tty() {
+    ( : < /dev/tty ) 2>/dev/null
+}
+
+# Prompts read /dev/tty, not stdin: under `curl | sh` stdin is the script.
+confirm() {
+    if ! has_tty; then
+        return 1
+    fi
+    printf '%s [y/N] ' "$1"
+    answer=""
+    read -r answer < /dev/tty || { printf '\n'; return 1; }
+    case "$answer" in
+        y|Y|yes|YES|Yes) return 0 ;;
+        *) return 1 ;;
+    esac
+}
+
+confirm_yes() {
+    if ! has_tty; then
+        return 0
+    fi
+    printf '%s [Y/n] ' "$1"
+    answer=""
+    read -r answer < /dev/tty || { printf '\n'; return 0; }
+    case "$answer" in
+        n|N|no|NO|No) return 1 ;;
+        *) return 0 ;;
+    esac
+}
+
+if [ "$(id -u)" -eq 0 ] && [ -n "${SUDO_USER:-}" ] && [ "$SUDO_USER" != "root" ]; then
+    fail "do not run this installer with sudo. It installs into your home directory and needs no root access."
+fi
+
+case "$(uname -s)" in
+    Darwin) os="macos" ;;
+    Linux) os="linux" ;;
+    *) fail "unsupported operating system: $(uname -s). The Gumloop CLI supports macOS and Linux (use WSL on Windows)." ;;
+esac
+
+case "$(uname -m)" in
+    x86_64|amd64) arch="x86_64" ;;
+    arm64|aarch64) arch="aarch64" ;;
+    *) fail "unsupported architecture: $(uname -m)" ;;
+esac
+
+if [ "$os" = "macos" ] && [ "$arch" = "x86_64" ]; then
+    if [ "$(sysctl -n sysctl.proc_translated 2>/dev/null || true)" = "1" ]; then
+        arch="aarch64"
+    fi
+fi
+
+if [ "$os" = "macos" ]; then
+    uv_target="${arch}-apple-darwin"
+    platform_label="macOS (${arch})"
+else
+    libc="gnu"
+    if ldd /bin/ls 2>&1 | grep -q musl; then
+        libc="musl"
+    fi
+    uv_target="${arch}-unknown-linux-${libc}"
+    platform_label="Linux (${arch}, ${libc})"
+fi
+
+downloader=""
+if command -v curl >/dev/null 2>&1; then
+    downloader="curl"
+elif command -v wget >/dev/null 2>&1; then
+    downloader="wget"
+else
+    fail "curl or wget is required to install the Gumloop CLI."
+fi
+
+download() {
+    url="$1"
+    output="$2"
+    if [ "$downloader" = "curl" ]; then
+        curl -fsSL -o "$output" "$url"
+    else
+        wget -q -O "$output" "$url"
+    fi
+}
+
+download_text() {
+    url="$1"
+    if [ "$downloader" = "curl" ]; then
+        curl -fsSL "$url"
+    else
+        wget -q -O - "$url"
+    fi
+}
+
+sha256_of() {
+    if command -v sha256sum >/dev/null 2>&1; then
+        sha256sum "$1" | cut -d' ' -f1
+    else
+        shasum -a 256 "$1" | cut -d' ' -f1
+    fi
+}
+
+if [ -x "$VENV_DIR/bin/gumloop" ]; then
+    install_mode="Updating"
+else
+    install_mode="Installing"
+fi
+
+step "${install_mode} Gumloop CLI"
+step "Detected platform: ${platform_label}"
+
+if [ "$install_mode" = "Updating" ]; then
+    installed_version="$("$VENV_DIR/bin/gumloop" --version 2>/dev/null || true)"
+    if ! confirm_yes "Gumloop CLI${installed_version:+ ${installed_version}} is already installed. Reinstall?"; then
+        step "Keeping the existing installation"
+        exit 0
+    fi
+fi
+
+tmp_dir="$(mktemp -d)"
+trap 'rm -rf "$tmp_dir"' EXIT INT TERM
+
+existing="$(command -v gumloop 2>/dev/null || true)"
+if [ -n "$existing" ] && [ "$existing" != "$SHIM_PATH" ]; then
+    case "$(readlink "$existing" 2>/dev/null || echo "$existing")" in
+        "$GUMLOOP_HOME"/*) ;;
+        *)
+            method="pip"
+            case "$existing" in
+                *pipx*) method="pipx" ;;
+                *"/uv/tools/"*) method="uv tool" ;;
+            esac
+            if confirm "Found existing gumloop at ${existing} (installed via ${method}). Remove it and switch to the managed install?"; then
+                step "Removing ${method} install"
+                case "$method" in
+                    pipx) pipx uninstall gumloop >/dev/null 2>&1 || warn "pipx uninstall failed; remove it manually with: pipx uninstall gumloop" ;;
+                    "uv tool") uv tool uninstall gumloop >/dev/null 2>&1 || warn "uv tool uninstall failed; remove it manually with: uv tool uninstall gumloop" ;;
+                    pip)
+                        shebang_python="$(head -n 1 "$existing" 2>/dev/null | sed 's/^#!//')"
+                        if [ -x "$shebang_python" ] && "$shebang_python" -m pip uninstall -y gumloop >/dev/null 2>&1; then
+                            :
+                        else
+                            warn "could not uninstall automatically; remove it manually with: pip uninstall gumloop"
+                        fi
+                        ;;
+                esac
+            else
+                warn "keeping the existing install; it may shadow the new 'gumloop' command on your PATH."
+            fi
+            ;;
+    esac
+fi
+
+uv_asset="uv-${uv_target}.tar.gz"
+uv_url="https://github.com/astral-sh/uv/releases/download/${UV_VERSION}/${uv_asset}"
+
+if [ -x "$UV_BIN" ] && [ "$("$UV_BIN" --version 2>/dev/null | cut -d' ' -f2)" = "$UV_VERSION" ]; then
+    :
+else
+    step "Downloading uv ${UV_VERSION}"
+    download "$uv_url" "$tmp_dir/$uv_asset"
+
+    expected_sha="$(download_text "${uv_url}.sha256" | cut -d' ' -f1)"
+    actual_sha="$(sha256_of "$tmp_dir/$uv_asset")"
+    if [ -z "$expected_sha" ] || [ "$expected_sha" != "$actual_sha" ]; then
+        fail "checksum verification failed for ${uv_asset}"
+    fi
+
+    tar -xzf "$tmp_dir/$uv_asset" -C "$tmp_dir"
+    mkdir -p "$GUMLOOP_HOME/bin"
+    mv "$tmp_dir/uv-${uv_target}/uv" "$UV_BIN"
+    chmod 0755 "$UV_BIN"
+fi
+
+if [ -n "${GUMLOOP_VERSION:-}" ]; then
+    install_spec="gumloop==${GUMLOOP_VERSION}"
+else
+    install_spec="gumloop"
+fi
+
+export UV_PYTHON_INSTALL_DIR="$GUMLOOP_HOME/python"
+export UV_CACHE_DIR="$GUMLOOP_HOME/cache"
+
+step "Installing Python ${PYTHON_VERSION} to ${GUMLOOP_HOME}"
+rm -rf "$VENV_DIR"
+# Without --managed-python uv silently reuses any system Python it finds.
+"$UV_BIN" venv "$VENV_DIR" --python "$PYTHON_VERSION" --managed-python --quiet
+
+step "Installing ${install_spec} from PyPI"
+"$UV_BIN" pip install --python "$VENV_DIR/bin/python" --quiet "$install_spec"
+
+version="$("$VENV_DIR/bin/python" -c 'from gumloop import __version__; print(__version__)')"
+step "Resolved version: ${version}"
+
+mkdir -p "$SHIM_DIR"
+ln -sf "$VENV_DIR/bin/gumloop" "$SHIM_PATH"
+
+cat > "$GUMLOOP_HOME/install.json" <<EOF
+{
+  "install_method": "installer",
+  "installer_version": "${INSTALLER_VERSION}",
+  "version": "${version}",
+  "installed_at": "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+}
+EOF
+
+"$SHIM_PATH" --version >/dev/null 2>&1 || fail "installed CLI failed to run; try re-running the installer."
+
+case ":$PATH:" in
+    *":$SHIM_DIR:"*)
+        step "${SHIM_DIR} is already on PATH"
+        ;;
+    *)
+        warn "${SHIM_DIR} is not on your PATH."
+        printf '\nAdd it to your shell profile (e.g. ~/.zshrc or ~/.bashrc):\n'
+        printf '    export PATH="%s:$PATH"\n\n' "$SHIM_DIR"
+        ;;
+esac
+
+printf '\n%s✓ Gumloop CLI %s installed successfully.%s\n' "${GREEN}" "${version}" "${RESET}"
+printf 'Run %sgumloop --help%s to get started, %sgumloop update%s to update.\n\n' \
+    "${BOLD}" "${RESET}" "${BOLD}" "${RESET}"
+
+login_state="$("$VENV_DIR/bin/python" - 2>/dev/null <<'EOF' || true
+from gumloop.cli.credentials import is_keyring_available, load_credentials
+
+if load_credentials().has_any:
+    print("logged_in")
+elif is_keyring_available():
+    print("prompt")
+else:
+    print("no_keyring")
+EOF
+)"
+
+case "$login_state" in
+    logged_in) ;;
+    no_keyring)
+        printf 'No OS keychain was found, so `gumloop login` cannot store credentials on this machine.\n'
+        printf 'Authenticate with environment variables instead (GUMLOOP_API_KEY + GUMLOOP_USER_ID),\n'
+        printf 'or install a keychain (e.g. apt install gnome-keyring libsecret-1-0) and run `gumloop login`.\n\n'
+        ;;
+    *)
+        if has_tty && confirm "Log in to Gumloop now?"; then
+            "$SHIM_PATH" login < /dev/tty || true
+        fi
+        ;;
+esac

{gumloop-0.4.2 → gumloop-0.4.4}/src/gumloop/_version.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.4.2"
+__version__ = "0.4.4"

gumloop-0.4.4/src/gumloop/cli/commands/update.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import threading
+import time
+from pathlib import Path
+
+import httpx
+import typer
+
+from gumloop import __version__
+from gumloop.cli.console import console
+from gumloop.cli.console import error_console
+
+PYPI_JSON_URL = "https://pypi.org/pypi/gumloop/json"
+UPDATE_CHECK_INTERVAL_SECONDS = 24 * 60 * 60
+
+
+def gumloop_home() -> Path:
+    override = os.environ.get("GUMLOOP_INSTALL_DIR")
+    return Path(override) if override else Path.home() / ".gumloop"
+
+
+def is_managed_install() -> bool:
+    try:
+        prefix = Path(sys.prefix).resolve()
+        return prefix == (gumloop_home() / "venv").resolve()
+    except OSError:
+        return False
+
+
+def fetch_latest_version(timeout: float = 10.0) -> str:
+    response = httpx.get(PYPI_JSON_URL, timeout=timeout, follow_redirects=True)
+    response.raise_for_status()
+    return response.json()["info"]["version"]
+
+
+def _version_tuple(version: str) -> tuple[int, ...] | None:
+    parts: list[int] = []
+    for part in version.split("."):
+        digits = ""
+        for char in part:
+            if not char.isdigit():
+                break
+            digits += char
+        if not digits:
+            return None
+        parts.append(int(digits))
+    return tuple(parts) if parts else None
+
+
+def is_newer(latest: str, current: str) -> bool:
+    latest_t = _version_tuple(latest)
+    current_t = _version_tuple(current)
+    if latest_t is None or current_t is None:
+        return latest != current
+    return latest_t > current_t
+
+
+def _non_managed_hint() -> str:
+    prefix = sys.prefix
+    if "pipx" in prefix:
+        return "pipx upgrade gumloop"
+    if f"{os.sep}uv{os.sep}tools{os.sep}" in prefix:
+        return "uv tool upgrade gumloop"
+    return "uv pip install --upgrade gumloop"
+
+
+def update() -> None:
+    """Update the Gumloop CLI to the latest version."""
+    try:
+        latest = fetch_latest_version()
+    except (httpx.HTTPError, KeyError, ValueError):
+        error_console.print("[red]Error:[/red] could not reach PyPI to check for updates.")
+        raise typer.Exit(1) from None
+
+    if not is_newer(latest, __version__):
+        console.print(f"gumloop {__version__} is already the latest version.")
+        return
+
+    if not is_managed_install():
+        console.print(
+            f"gumloop [bold]{latest}[/bold] is available (you have {__version__}).\n"
+            f"This install is not managed by the Gumloop installer; update it with:\n"
+            f"    [bold]{_non_managed_hint()}[/bold]"
+        )
+        return
+
+    home = gumloop_home()
+    uv = home / "bin" / "uv"
+    python = home / "venv" / "bin" / "python"
+    if not uv.is_file() or not python.is_file():
+        error_console.print(
+            "[red]Error:[/red] managed install is missing its uv or Python. Repair it by re-running:\n"
+            "    curl -fsSL https://gumloop.com/cli/install.sh | sh"
+        )
+        raise typer.Exit(1)
+
+    console.print(f"Updating gumloop {__version__} -> [bold]{latest}[/bold] ...")
+    env = os.environ.copy()
+    env["UV_PYTHON_INSTALL_DIR"] = str(home / "python")
+    env["UV_CACHE_DIR"] = str(home / "cache")
+    result = subprocess.run(
+        [str(uv), "pip", "install", "--python", str(python), "--quiet", f"gumloop=={latest}"],
+        env=env,
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        error_console.print(f"[red]Error:[/red] update failed:\n{result.stderr.strip()}")
+        raise typer.Exit(1)
+
+    _write_check_state(latest)
+    console.print(f"[green]Updated to gumloop {latest}.[/green]")
+
+
+def _check_state_path() -> Path:
+    return gumloop_home() / "update_check.json"
+
+
+def _write_check_state(latest: str) -> None:
+    try:
+        path = _check_state_path()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps({"checked_at": time.time(), "latest": latest}))
+    except OSError:
+        pass
+
+
+def _refresh_check_state() -> None:
+    try:
+        _write_check_state(fetch_latest_version(timeout=5.0))
+    except Exception:
+        pass
+
+
+def maybe_notify_update() -> None:
+    """Runs on every CLI invocation; must never block or raise."""
+    try:
+        if os.environ.get("GUMLOOP_NO_UPDATE_CHECK") or os.environ.get("CI"):
+            return
+        if not sys.stderr.isatty():
+            return
+
+        state: dict[str, object] = {}
+        try:
+            state = json.loads(_check_state_path().read_text())
+        except (OSError, json.JSONDecodeError):
+            pass
+
+        checked_at = state.get("checked_at")
+        stale = not isinstance(checked_at, (int, float)) or time.time() - checked_at > UPDATE_CHECK_INTERVAL_SECONDS
+        if stale:
+            threading.Thread(target=_refresh_check_state, daemon=True).start()
+
+        latest = state.get("latest")
+        if isinstance(latest, str) and is_newer(latest, __version__):
+            command = "gumloop update" if is_managed_install() else _non_managed_hint()
+            error_console.print(f"[dim]A new version of gumloop is available: {latest} (run `{command}`).[/dim]")
+    except Exception:
+        pass

{gumloop-0.4.2 → gumloop-0.4.4}/src/gumloop/cli/main.py

@@ -17,6 +17,8 @@ from gumloop.cli.commands.mcp import mcp_app
 from gumloop.cli.commands.sessions import sessions_app
 from gumloop.cli.commands.skills import skills_app
 from gumloop.cli.commands.sync import sync_app
+from gumloop.cli.commands.update import maybe_notify_update
+from gumloop.cli.commands.update import update as update_command
 from gumloop.cli.context import CliContext
 from gumloop.cli.credentials import load_credentials
 
@@ -93,6 +95,7 @@ app.command("login", epilog="Examples:\n  gumloop login\n  gumloop login --api-k
     login_command
 )
 app.command("logout")(logout_command)
+app.command("update")(update_command)
 app.add_typer(mcp_app, name="mcp")
 app.add_typer(agents_app, name="agents")
 app.add_typer(sessions_app, name="sessions")
@@ -119,6 +122,8 @@ def _require_supported_platform() -> None:
 
 def main() -> None:
     _require_supported_platform()
+    if sys.argv[1:2] != ["update"]:
+        maybe_notify_update()
     app()
 
 

{gumloop-0.4.2 → gumloop-0.4.4}/src/gumloop/types.py

@@ -180,6 +180,14 @@ class MessagePayload(_Model):
     parts: list[dict[str, Any]] | None = None
 
 
+class SessionUsage(_Model):
+    credit_cost: float | None = None
+    tool_credit_cost: float | None = None
+    flow_credit_cost: float | None = None
+    input_tokens: int | None = None
+    output_tokens: int | None = None
+
+
 class Session(_Model):
     id: str
     agent_id: str
@@ -195,6 +203,7 @@ class Session(_Model):
     agent_tools: list[dict[str, Any]] = Field(default_factory=list)
     participants: dict[str, dict[str, Any]] = Field(default_factory=dict)
     creator: CreatorPayload | None = None
+    usage: SessionUsage | None = None
 
 
 class SessionResponse(_Model):

{gumloop-0.4.2 → gumloop-0.4.4}/uv.lock

@@ -355,7 +355,6 @@ wheels = [
 
 [[package]]
 name = "gumloop"
-version = "0.4.2"
 source = { editable = "." }
 dependencies = [
     { name = "click" },