@clawpump/claw-agent 0.1.5 → 0.1.7

package/agent/hermes_cli/gui_uninstall.py

@@ -0,0 +1,285 @@
+"""
+Hermes Desktop (Chat GUI) uninstaller.
+
+The desktop GUI ships in two shapes and this module knows how to find and
+remove the artifacts of both, on Linux, macOS, and Windows, WITHOUT touching
+the Python agent or the user's config/data:
+
+  1. Source-built GUI (``hermes desktop`` / ``hermes gui``)
+     Built inside the agent checkout under ``$HERMES_HOME/hermes-agent/``:
+       - ``apps/desktop/dist``      (compiled renderer)
+       - ``apps/desktop/release``   (electron-builder unpacked app + installers)
+       - ``apps/desktop/node_modules`` and the workspace-root ``node_modules``
+         (Electron itself, ~200MB) — only removed on a GUI uninstall because
+         the agent does not need them.
+       - ``$HERMES_HOME/desktop-build-stamp.json`` (the build freshness stamp)
+
+  2. Packaged distributable (DMG / NSIS / AppImage / deb / rpm)
+     Installed by the OS to a standard application location and carrying its
+     own bundled Electron + a per-user Electron ``userData`` directory:
+       - macOS:   ``/Applications/Hermes.app`` or ``~/Applications/Hermes.app``
+       - Windows: ``%LOCALAPPDATA%\\Programs\\Hermes`` (NSIS per-user)
+       - Linux:   ``~/.local/share/applications`` .desktop entry + AppImage
+
+In both shapes the Electron runtime keeps a ``userData`` directory keyed on
+the app name ("Hermes"), separate from ``$HERMES_HOME``:
+  - macOS:   ``~/Library/Application Support/Hermes``
+  - Windows: ``%APPDATA%\\Hermes``
+  - Linux:   ``$XDG_CONFIG_HOME/Hermes`` (default ``~/.config/Hermes``)
+
+This holds the desktop's own ``connection.json`` / ``updates.json`` and
+Chromium cache — pure GUI state, safe to remove on a GUI uninstall.
+
+The functions here are deliberately import-light and side-effect-free at
+import time so the Electron main process can shell out to
+``hermes uninstall --gui`` (and friends) without paying for the full CLI.
+"""
+
+import os
+import shutil
+import sys
+from pathlib import Path
+
+from hermes_constants import get_hermes_home
+
+from hermes_cli.colors import Colors, color
+
+
+def log_info(msg: str):
+    print(f"{color('→', Colors.CYAN)} {msg}")
+
+
+def log_success(msg: str):
+    print(f"{color('✓', Colors.GREEN)} {msg}")
+
+
+def log_warn(msg: str):
+    print(f"{color('⚠', Colors.YELLOW)} {msg}")
+
+
+# ---------------------------------------------------------------------------
+# Discovery
+# ---------------------------------------------------------------------------
+
+
+def _agent_root(hermes_home: Path) -> Path:
+    """The agent checkout root — same layout install.sh / install.ps1 use."""
+    return hermes_home / "hermes-agent"
+
+
+def desktop_userdata_dir() -> Path:
+    """Return the Electron ``userData`` directory for the desktop app.
+
+    Mirrors Electron's ``app.getPath('userData')`` for an app named "Hermes"
+    on each platform. This is GUI-only state (connection.json, updates.json,
+    Chromium cache) and never holds agent config or sessions.
+    """
+    home = Path.home()
+    if sys.platform == "darwin":
+        return home / "Library" / "Application Support" / "Hermes"
+    if sys.platform == "win32":
+        appdata = os.environ.get("APPDATA")
+        base = Path(appdata) if appdata else (home / "AppData" / "Roaming")
+        return base / "Hermes"
+    # Linux / other POSIX — XDG config home.
+    xdg = os.environ.get("XDG_CONFIG_HOME")
+    base = Path(xdg) if xdg else (home / ".config")
+    return base / "Hermes"
+
+
+def source_built_gui_artifacts(hermes_home: Path) -> "list[Path]":
+    """GUI build artifacts produced by ``hermes desktop`` inside the checkout.
+
+    These are removable on a GUI uninstall without harming the agent: the
+    Python agent runs from ``hermes-agent/`` source + ``venv/`` and never
+    needs the Electron build output or node_modules.
+    """
+    agent_root = _agent_root(hermes_home)
+    desktop_dir = agent_root / "apps" / "desktop"
+    return [
+        desktop_dir / "dist",
+        desktop_dir / "release",
+        desktop_dir / "node_modules",
+        # Workspace-root node_modules carries Electron (devDependency of the
+        # desktop workspace, ~200MB). The agent does not use any npm package,
+        # so this is GUI tooling — safe to drop on a GUI uninstall.
+        agent_root / "node_modules",
+        hermes_home / "desktop-build-stamp.json",
+    ]
+
+
+def packaged_gui_app_paths() -> "list[Path]":
+    """Standard install locations of the packaged desktop distributable.
+
+    Returns every candidate for the current OS; the caller filters to those
+    that actually exist. We never glob system-wide — only the well-known
+    electron-builder output locations for the "Hermes" product.
+    """
+    home = Path.home()
+    paths: list[Path] = []
+    if sys.platform == "darwin":
+        paths += [
+            Path("/Applications/Hermes.app"),
+            home / "Applications" / "Hermes.app",
+        ]
+    elif sys.platform == "win32":
+        local = os.environ.get("LOCALAPPDATA")
+        local_base = Path(local) if local else (home / "AppData" / "Local")
+        paths += [
+            # NSIS per-user install (perMachine=false → Programs\Hermes).
+            local_base / "Programs" / "Hermes",
+            # Older / alternate layout some builds used.
+            local_base / "hermes-desktop",
+        ]
+        program_files = os.environ.get("ProgramFiles")
+        if program_files:
+            # NSIS per-machine fallback (needs admin to remove).
+            paths.append(Path(program_files) / "Hermes")
+    else:
+        # Linux: AppImage is a single file the user placed somewhere; we can
+        # only reliably clean the desktop entry + icon we know the name of.
+        # The AppImage itself lives wherever the user put it, so we surface a
+        # hint rather than guessing. deb/rpm installs are owned by the system
+        # package manager and must be removed via apt/dnf — see the message in
+        # ``uninstall_gui``.
+        data = os.environ.get("XDG_DATA_HOME")
+        data_base = Path(data) if data else (home / ".local" / "share")
+        paths += [
+            data_base / "applications" / "hermes.desktop",
+            data_base / "applications" / "Hermes.desktop",
+        ]
+    return paths
+
+
+def agent_is_installed(hermes_home: Path) -> bool:
+    """Return True when a usable Python agent install exists under HERMES_HOME.
+
+    Used by the desktop UI to decide which uninstall options to offer: if the
+    agent isn't present (a future "lite" GUI-only client), the "remove agent"
+    options are hidden.
+    """
+    agent_root = _agent_root(hermes_home)
+    # A real install has the package source + a venv. Either signal alone is
+    # enough — a source checkout without a venv is still "the agent is here".
+    if (agent_root / "hermes_cli").is_dir():
+        return True
+    if (agent_root / "venv").is_dir() or (agent_root / ".venv").is_dir():
+        return True
+    return False
+
+
+def gui_is_installed(hermes_home: Path) -> bool:
+    """Return True when any desktop GUI artifact exists (built or packaged)."""
+    for p in source_built_gui_artifacts(hermes_home):
+        if p.exists():
+            return True
+    for p in packaged_gui_app_paths():
+        if p.exists():
+            return True
+    if desktop_userdata_dir().exists():
+        return True
+    return False
+
+
+def gui_install_summary(hermes_home: "Path | None" = None) -> dict:
+    """Structured snapshot of what's installed, for the desktop UI to render.
+
+    Returns JSON-serializable primitives so the Electron main process can
+    forward it to the renderer via IPC (paths as strings, booleans for the
+    high-level questions the UI gates options on).
+    """
+    home: Path = hermes_home if hermes_home is not None else get_hermes_home()
+
+    source_artifacts = [p for p in source_built_gui_artifacts(home) if p.exists()]
+    packaged = [p for p in packaged_gui_app_paths() if p.exists()]
+    userdata = desktop_userdata_dir()
+
+    return {
+        "hermes_home": str(home),
+        "agent_installed": agent_is_installed(home),
+        "gui_installed": gui_is_installed(home),
+        "source_built_artifacts": [str(p) for p in source_artifacts],
+        "packaged_app_paths": [str(p) for p in packaged],
+        "userdata_dir": str(userdata),
+        "userdata_exists": userdata.exists(),
+        "platform": sys.platform,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Removal
+# ---------------------------------------------------------------------------
+
+
+def _remove_path(path: Path) -> bool:
+    """Remove a file or directory tree. Returns True when something was removed."""
+    try:
+        if path.is_symlink() or path.is_file():
+            path.unlink()
+            return True
+        if path.is_dir():
+            shutil.rmtree(path)
+            return True
+    except Exception as e:
+        log_warn(f"Could not remove {path}: {e}")
+    return False
+
+
+def uninstall_gui(hermes_home: "Path | None" = None, *, remove_userdata: bool = True) -> "list[Path]":
+    """Remove the desktop GUI's artifacts, leaving the agent + user data intact.
+
+    Removes:
+      - source-built GUI artifacts (dist/release/node_modules/build-stamp)
+      - the packaged app bundle / install dir (best-effort; deb/rpm need the
+        system package manager and are reported, not force-removed)
+      - the Electron ``userData`` directory (unless ``remove_userdata=False``)
+
+    Never touches ``hermes-agent/hermes_cli`` (agent source), ``venv/``, or any
+    config / sessions / .env under ``$HERMES_HOME``.
+
+    Returns the list of paths actually removed.
+    """
+    home: Path = hermes_home if hermes_home is not None else get_hermes_home()
+
+    removed: list[Path] = []
+
+    log_info("Removing built GUI artifacts (renderer, release, node_modules)...")
+    for path in source_built_gui_artifacts(home):
+        if path.exists() and _remove_path(path):
+            log_success(f"Removed {path}")
+            removed.append(path)
+
+    log_info("Removing installed desktop app...")
+    found_packaged = False
+    for path in packaged_gui_app_paths():
+        if path.exists():
+            found_packaged = True
+            if _remove_path(path):
+                log_success(f"Removed {path}")
+                removed.append(path)
+    if not found_packaged:
+        log_info("No packaged desktop app found in standard locations")
+
+    if remove_userdata:
+        userdata = desktop_userdata_dir()
+        if userdata.exists():
+            log_info("Removing desktop app data (Electron userData)...")
+            if _remove_path(userdata):
+                log_success(f"Removed {userdata}")
+                removed.append(userdata)
+
+    if not removed:
+        log_info("No desktop GUI artifacts found to remove")
+
+    # Linux deb/rpm installs are owned by the package manager; we can't (and
+    # shouldn't) rmtree files under /usr. Surface the hint so the user can
+    # finish the job. AppImages live wherever the user dropped them.
+    if sys.platform.startswith("linux"):
+        log_info(
+            "If you installed the desktop via a .deb / .rpm package, remove it "
+            "with your package manager (e.g. 'sudo apt remove hermes' or "
+            "'sudo dnf remove hermes'). AppImage builds are a single file you "
+            "can delete from wherever you saved it."
+        )
+
+    return removed

package/agent/hermes_cli/inventory.py

@@ -115,7 +115,10 @@ def build_models_payload(
     picker_hints: bool = False,
     canonical_order: bool = False,
     pricing: bool = False,
-    max_models: int = 50,
+    capabilities: bool = False,
+    force_fresh_nous_tier: bool = False,
+    refresh: bool = False,
+    max_models: int | None = None,
 ) -> dict:
     """Build the ``{providers, model, provider}`` shape every consumer
     needs from a single substrate call.
@@ -134,6 +137,18 @@ def build_models_payload(
       show $/Mtok columns and gate paid models on free accounts —
       mirroring the ``hermes model`` CLI picker. Adds network calls
       (pricing fetch + Nous tier check); only set for interactive pickers.
+    - ``capabilities``: add a per-row ``capabilities`` map
+      ``{model: {fast, reasoning}}`` so pickers can gate the model-options
+      controls (fast toggle / reasoning) to what each model actually
+      supports, instead of offering knobs the backend would reject.
+    - ``force_fresh_nous_tier``: bypass the short Nous free-tier cache when
+      selecting Portal-recommended Nous models and applying tier gating. Keep
+      this false for UI picker opens; explicit auth/model flows can opt in
+      when they need freshly-purchased credits to show up immediately.
+    - ``refresh``: bust the per-provider model-id disk cache so every row
+      re-fetches its live catalog. Set only for an explicit user-triggered
+      "refresh models" action; normal picker opens leave it false to stay
+      snappy on the 1h cache.
     """
     from hermes_cli.model_switch import list_authenticated_providers
 
@@ -143,9 +158,49 @@ def build_models_payload(
         current_model=ctx.current_model,
         user_providers=ctx.user_providers,
         custom_providers=ctx.custom_providers,
+        force_fresh_nous_tier=force_fresh_nous_tier,
         max_models=max_models,
+        refresh=refresh,
     )
 
+    # --- Deduplicate: remove models from aggregators that overlap with
+    # user-defined providers.  When a local proxy (e.g. litellm-proxy)
+    # serves a model whose name also appears in an aggregator's curated
+    # catalog, the picker would show the model under both providers.
+    # Selecting it from the aggregator row sets model.provider to the
+    # aggregator (e.g. openrouter) instead of the user's proxy — silently
+    # breaking the call.  Filtering at the payload level keeps the
+    # aggregator rows honest: they only show models the user can't get
+    # from a more-specific provider.  (#45954)
+    try:
+        from hermes_cli.providers import is_aggregator as _is_aggregator
+    except Exception:
+        _is_aggregator = None  # type: ignore[assignment]
+
+    if _is_aggregator is not None:
+        user_models: set[str] = set()
+        for row in rows:
+            if row.get("is_user_defined"):
+                user_models.update(m.lower() for m in (row.get("models") or []))
+        if user_models:
+            for row in rows:
+                # A user's own configured provider is never an "aggregator
+                # duplicate" of itself: user_models is built from these very
+                # rows, and is_aggregator() reports True for every custom:*
+                # slug.  Without this guard the dedup strips a user-defined
+                # custom provider's entire model list (all of it lives in
+                # user_models), emptying its picker row.
+                if row.get("is_user_defined"):
+                    continue
+                slug = row.get("slug", "")
+                if not _is_aggregator(slug):
+                    continue
+                original = row.get("models") or []
+                filtered = [m for m in original if m.lower() not in user_models]
+                if len(filtered) < len(original):
+                    row["models"] = filtered
+                    row["total_models"] = len(filtered)
+
     if include_unconfigured:
         rows = list(rows) + _append_unconfigured_rows(rows, ctx)
     if picker_hints:
@@ -153,7 +208,9 @@ def build_models_payload(
     if canonical_order:
         rows = _reorder_canonical(rows)
     if pricing:
-        _apply_pricing(rows)
+        _apply_pricing(rows, force_fresh_nous_tier=force_fresh_nous_tier)
+    if capabilities:
+        _apply_capabilities(rows)
 
     return {
         "providers": rows,
@@ -162,6 +219,44 @@ def build_models_payload(
     }
 
 
+def _apply_capabilities(rows: list[dict]) -> None:
+    """Attach a ``{model: {fast, reasoning}}`` map to each provider row.
+
+    `fast` mirrors ``model_supports_fast_mode`` (the same gate the runtime
+    enforces). `reasoning` comes from the models.dev catalog when known and
+    defaults to True otherwise — the effort dial is broadly accepted and a
+    no-op on models that ignore it, whereas hiding it from a capable-but-
+    uncatalogued model is the worse failure.
+    """
+    from hermes_cli.models import model_supports_fast_mode
+
+    try:
+        from agent.models_dev import get_model_capabilities
+    except Exception:
+        get_model_capabilities = None  # type: ignore[assignment]
+
+    for row in rows:
+        slug = row.get("slug") or ""
+        caps: dict[str, dict[str, bool]] = {}
+
+        for model in row.get("models") or []:
+            reasoning = True
+            if get_model_capabilities is not None and slug:
+                try:
+                    meta = get_model_capabilities(slug, model)
+                    if meta is not None:
+                        reasoning = bool(meta.supports_reasoning)
+                except Exception:
+                    reasoning = True
+
+            caps[model] = {
+                "fast": bool(model_supports_fast_mode(model)),
+                "reasoning": reasoning,
+            }
+
+        row["capabilities"] = caps
+
+
 # ─── Internal: row post-processing ──────────────────────────────────────
 
 
@@ -248,7 +343,11 @@ def _reorder_canonical(rows: list[dict]) -> list[dict]:
     return canon + extras
 
 
-def _apply_pricing(rows: list[dict]) -> None:
+def _apply_pricing(
+    rows: list[dict],
+    *,
+    force_fresh_nous_tier: bool = False,
+) -> None:
     """Enrich each provider row with per-model pricing + Nous tier gating.
 
     Mutates ``rows`` in-place. For every row whose provider supports live
@@ -314,7 +413,9 @@ def _apply_pricing(rows: list[dict]) -> None:
         if slug == "nous":
             try:
                 if nous_free_tier is None:
-                    nous_free_tier = check_nous_free_tier(force_fresh=True)
+                    nous_free_tier = check_nous_free_tier(
+                        force_fresh=force_fresh_nous_tier
+                    )
                 row["free_tier"] = bool(nous_free_tier)
                 if nous_free_tier:
                     _selectable, unavailable = partition_nous_models_by_tier(

package/agent/hermes_cli/kanban.py

@@ -15,6 +15,7 @@ Exposes the full Kanban command surface documented in the design spec
 from __future__ import annotations
 
 import argparse
+import contextlib
 import json
 import os
 import shlex
@@ -884,16 +885,7 @@ def kanban_command(args: argparse.Namespace) -> int:
     # keeps the patch small and inherits the exact same resolution the
     # dispatcher uses for workers — consistency is a feature here.
     board_override = getattr(args, "board", None)
-    prev_board_env = os.environ.get("HERMES_KANBAN_BOARD")
-    restore_board_env = False
-
-    def _restore_board_env() -> None:
-        if not restore_board_env:
-            return
-        if prev_board_env is None:
-            os.environ.pop("HERMES_KANBAN_BOARD", None)
-        else:
-            os.environ["HERMES_KANBAN_BOARD"] = prev_board_env
+    board_scope = contextlib.nullcontext()
     if board_override:
         try:
             normed = kb._normalize_board_slug(board_override)
@@ -912,8 +904,7 @@ def kanban_command(args: argparse.Namespace) -> int:
                 file=sys.stderr,
             )
             return 1
-        os.environ["HERMES_KANBAN_BOARD"] = normed
-        restore_board_env = True
+        board_scope = kb.scoped_current_board(normed)
 
     # Auto-initialize the DB before dispatching any subcommand. init_db
     # is idempotent, so running it every invocation is cheap (one
@@ -922,66 +913,62 @@ def kanban_command(args: argparse.Namespace) -> int:
     # HERMES_HOME. Previously only `init` and `daemon` triggered
     # schema creation; `create` / `list` / every other command would
     # error out on a fresh install.
-    try:
-        kb.init_db()
-    except Exception as exc:
-        print(f"kanban: could not initialize database: {exc}", file=sys.stderr)
-        _restore_board_env()
-        return 1
+    with board_scope:
+        try:
+            kb.init_db()
+        except Exception as exc:
+            print(f"kanban: could not initialize database: {exc}", file=sys.stderr)
+            return 1
 
-    handlers = {
-        "init":     _cmd_init,
-        "create":   _cmd_create,
-        "swarm":    _cmd_swarm,
-        "list":     _cmd_list,
-        "ls":       _cmd_list,
-        "show":     _cmd_show,
-        "assign":   _cmd_assign,
-        "reclaim":  _cmd_reclaim,
-        "reassign": _cmd_reassign,
-        "diagnostics": _cmd_diagnostics,
-        "diag":     _cmd_diagnostics,
-        "link":     _cmd_link,
-        "unlink":   _cmd_unlink,
-        "claim":    _cmd_claim,
-        "comment":  _cmd_comment,
-        "complete": _cmd_complete,
-        "edit":     _cmd_edit,
-        "block":    _cmd_block,
-        "schedule": _cmd_schedule,
-        "unblock":  _cmd_unblock,
-        "promote":  _cmd_promote,
-        "archive":  _cmd_archive,
-        "tail":     _cmd_tail,
-        "dispatch": _cmd_dispatch,
-        "daemon":   _cmd_daemon,
-        "watch":    _cmd_watch,
-        "stats":    _cmd_stats,
-        "log":      _cmd_log,
-        "runs":     _cmd_runs,
-        "heartbeat": _cmd_heartbeat,
-        "assignees": _cmd_assignees,
-        "notify-subscribe":   _cmd_notify_subscribe,
-        "notify-list":        _cmd_notify_list,
-        "notify-unsubscribe": _cmd_notify_unsubscribe,
-        "context":  _cmd_context,
-        "specify":  _cmd_specify,
-        "decompose":  _cmd_decompose,
-        "gc":       _cmd_gc,
-    }
-    handler = handlers.get(action)
-    if not handler:
-        print(f"kanban: unknown action {action!r}", file=sys.stderr)
-        _restore_board_env()
-        return 2
-    try:
-        return int(handler(args) or 0)
-    except (ValueError, RuntimeError) as exc:
-        print(f"kanban: {exc}", file=sys.stderr)
-        _restore_board_env()
-        return 1
-    finally:
-        _restore_board_env()
+        handlers = {
+            "init":     _cmd_init,
+            "create":   _cmd_create,
+            "swarm":    _cmd_swarm,
+            "list":     _cmd_list,
+            "ls":       _cmd_list,
+            "show":     _cmd_show,
+            "assign":   _cmd_assign,
+            "reclaim":  _cmd_reclaim,
+            "reassign": _cmd_reassign,
+            "diagnostics": _cmd_diagnostics,
+            "diag":     _cmd_diagnostics,
+            "link":     _cmd_link,
+            "unlink":   _cmd_unlink,
+            "claim":    _cmd_claim,
+            "comment":  _cmd_comment,
+            "complete": _cmd_complete,
+            "edit":     _cmd_edit,
+            "block":    _cmd_block,
+            "schedule": _cmd_schedule,
+            "unblock":  _cmd_unblock,
+            "promote":  _cmd_promote,
+            "archive":  _cmd_archive,
+            "tail":     _cmd_tail,
+            "dispatch": _cmd_dispatch,
+            "daemon":   _cmd_daemon,
+            "watch":    _cmd_watch,
+            "stats":    _cmd_stats,
+            "log":      _cmd_log,
+            "runs":     _cmd_runs,
+            "heartbeat": _cmd_heartbeat,
+            "assignees": _cmd_assignees,
+            "notify-subscribe":   _cmd_notify_subscribe,
+            "notify-list":        _cmd_notify_list,
+            "notify-unsubscribe": _cmd_notify_unsubscribe,
+            "context":  _cmd_context,
+            "specify":  _cmd_specify,
+            "decompose":  _cmd_decompose,
+            "gc":       _cmd_gc,
+        }
+        handler = handlers.get(action)
+        if not handler:
+            print(f"kanban: unknown action {action!r}", file=sys.stderr)
+            return 2
+        try:
+            return int(handler(args) or 0)
+        except (ValueError, RuntimeError) as exc:
+            print(f"kanban: {exc}", file=sys.stderr)
+            return 1
 
 
 # ---------------------------------------------------------------------------