mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-16 02:46:38 +03:00
b86c0b6878
A provider plugin was imported once per process, and the forced plugin sweep skips model providers, so an update never reached a running gateway. A plugin importing part of its package on first use then ran one new file against siblings loaded from the old tree (cannot import name ...), while the update surfaces said nothing needed a restart. The forced sweep now re-scans the profile's provider plugins; one whose tree changed (catalog pin, else file mtimes) is dropped whole (package, submodules, its profiles) and imported again. hermes plugins update reports activation like install/enable, the gateway auto-apply tick reloads in-process, and a model provider's activation summary says it was reloaded or why it failed. Fixes #153300
163 lines
7.7 KiB
Python
163 lines
7.7 KiB
Python
"""``hermes plugins update`` with no name: update every installed plugin that has an update.
|
|
|
|
The list comes from the read-only ``check-updates`` probe (:func:`hermes_cli.plugins_updates.run_checks`);
|
|
each plugin is then updated through the single-plugin
|
|
path (:func:`~hermes_cli.plugins_cmd_update.update_one`), so catalog consent, the security scan and
|
|
capability re-consent still apply per plugin.
|
|
|
|
Sibling of :mod:`hermes_cli.plugins_cmd` (the facade is imported late, never at module level).
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
import sys
|
|
from dataclasses import dataclass, field
|
|
from typing import Any
|
|
|
|
# Only these classes have an update path `hermes plugins update <name>` can drive: a catalog install
|
|
# re-pins to the reviewed sha, a tracked git install pulls. A pip row is a PyPI distribution that
|
|
# Hermes never upgrades (#132494), so offering it would promise an update nothing applies.
|
|
_UPDATE_KIND = {"catalog": "catalog re-pin", "git": "git pull"}
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def _pc():
|
|
from hermes_cli import plugins_cmd
|
|
return plugins_cmd
|
|
|
|
|
|
@dataclass
|
|
class UpdatePlan:
|
|
"""What ``update`` with no name would do: *movable* rows it updates, *skipped* ``(row, reason)``
|
|
pairs it cannot move, *current* the count already up to date."""
|
|
|
|
movable: list[Any] = field(default_factory=list)
|
|
skipped: list[tuple[Any, str]] = field(default_factory=list)
|
|
current: int = 0
|
|
|
|
|
|
def plan_update_all(results: list[Any], installs: dict | None = None) -> UpdatePlan:
|
|
"""Split ``run_checks`` rows into the plugins ``update`` can move and the ones it cannot (with why).
|
|
*installs* (the install records the check ran against) lets a catalog install held with ``--ref``
|
|
be skipped: only naming it (``hermes plugins update <name>``) moves it."""
|
|
from hermes_cli.plugins_auto_update import HELD_WITH_REF, held_with_ref
|
|
from hermes_cli.plugins_updates import held_for_newer_hermes
|
|
plan = UpdatePlan()
|
|
installs = installs or {}
|
|
for row in results:
|
|
if row.needs_fixing:
|
|
plan.skipped.append((row, f"needs fixing: {row.needs_fixing}"))
|
|
elif row.update_available is True and (held := held_for_newer_hermes(row)):
|
|
plan.skipped.append((row, f"update available after updating Hermes ({held})"))
|
|
elif row.update_available is True and held_with_ref(installs.get(row.name)):
|
|
plan.skipped.append((row, HELD_WITH_REF.format(name=row.name)))
|
|
elif row.update_available is True and row.klass in _UPDATE_KIND:
|
|
plan.movable.append(row)
|
|
elif row.update_available is True:
|
|
plan.skipped.append((row, f"{row.klass} distribution; Hermes does not upgrade it"))
|
|
elif row.update_available is None:
|
|
plan.skipped.append((row, row.reason or "update status unknown"))
|
|
elif row.reason: # up to date by construction but worth naming (pinned)
|
|
plan.skipped.append((row, row.reason))
|
|
else:
|
|
plan.current += 1
|
|
return plan
|
|
|
|
|
|
def _short(reason: str) -> str:
|
|
first = reason.strip().splitlines()[0] if reason.strip() else ""
|
|
return first if len(first) <= 200 else first[:197] + "..."
|
|
|
|
|
|
def _update_one(row, console, *, interactive: bool) -> tuple[str, str]:
|
|
"""Run the single-plugin update for one plan row; return ``(status, detail)``, status being
|
|
updated/current/failed. A refusal is printed like ``update <name>`` prints it, then recorded."""
|
|
from rich.markup import escape
|
|
from hermes_cli.plugins_cmd_catalog import RepinConsentRequired
|
|
from hermes_cli.plugins_cmd_update import update_one
|
|
target = _pc()._user_installed_plugin_dir(row.name)
|
|
if target is None:
|
|
return "failed", "no longer installed"
|
|
try:
|
|
moved = update_one(row.name, target, console, interactive=interactive)
|
|
except RepinConsentRequired as exc:
|
|
console.print(f"[yellow]Update of {escape(row.name)} not applied:[/yellow] {escape(str(exc))}")
|
|
return "failed", _short(f"not applied: {exc}")
|
|
except _pc().PluginOperationError as exc:
|
|
console.print(f"[red]Error:[/red] {escape(str(exc))}")
|
|
return "failed", _short(str(exc))
|
|
except Exception as exc: # per-plugin batch boundary: a feed timeout or crash must not stop the rest
|
|
logger.warning("update of plugin %s failed", row.name, exc_info=True)
|
|
console.print(f"[red]Error:[/red] {escape(type(exc).__name__)}: {escape(str(exc))}")
|
|
return "failed", _short(f"{type(exc).__name__}: {exc}")
|
|
if not moved:
|
|
return "current", ""
|
|
from hermes_cli.plugins_activation import report_activation
|
|
report_activation(console, target.name) # load it in the running gateway, like `update <name>`
|
|
return "updated", f"{(row.current or '')[:8]}..{(row.latest or '')[:8]}"
|
|
|
|
|
|
def _print_plan(console, plan: UpdatePlan) -> None:
|
|
from rich.markup import escape
|
|
table = _pc()._table([("#", "dim"), ("Plugin", "bold"), ("Current", ""), ("Latest", ""), ("Update", "")],
|
|
title="Plugin updates available")
|
|
for i, row in enumerate(plan.movable, 1):
|
|
table.add_row(str(i), row.name, (row.current or "-")[:12], (row.latest or "-")[:12], _UPDATE_KIND[row.klass])
|
|
console.print()
|
|
console.print(table)
|
|
for row, reason in plan.skipped:
|
|
console.print(f" [dim]skipped {escape(row.name)} ({row.klass}): {escape(reason)}[/dim]")
|
|
|
|
|
|
def cmd_update_all(*, yes: bool = False) -> None:
|
|
"""``hermes plugins update [--yes]``: list the plugins with an update and update them all.
|
|
|
|
A terminal asks once (``Update all N? [Y/n]``); without one nothing moves unless ``--yes`` is
|
|
given. Each plugin then goes through ``update_one``, interactive only when a terminal is present,
|
|
so per-plugin consent prompts still appear there and stay closed (fail closed) under ``--yes``
|
|
in scripts. One failure does not stop the rest; exit 1 when any update failed.
|
|
"""
|
|
from rich.markup import escape
|
|
from hermes_cli.plugins_updates import run_checks
|
|
|
|
console = _pc()._console()
|
|
console.print("[dim]Checking installed plugins for updates...[/dim]")
|
|
from hermes_cli.plugins_cadence import snapshot_installs
|
|
plugins_dir = _pc()._plugins_dir()
|
|
checked = snapshot_installs(plugins_dir)
|
|
plan = plan_update_all(run_checks(plugins_dir), checked)
|
|
if not plan.movable:
|
|
for row, reason in plan.skipped:
|
|
console.print(f" [dim]skipped {escape(row.name)} ({row.klass}): {escape(reason)}[/dim]")
|
|
console.print("[green]✓[/green] No plugin updates to apply.")
|
|
return
|
|
_print_plan(console, plan)
|
|
count = len(plan.movable)
|
|
tty = _pc()._is_tty()
|
|
if not yes:
|
|
if not tty:
|
|
_pc()._fail(console, f"[yellow]Not updating: no terminal to confirm. Re-run with --yes to update "
|
|
f"these {count} plugin(s).[/yellow]")
|
|
try:
|
|
answer = input(f"\nUpdate all {count}? [Y/n]: ").strip().lower()
|
|
except (EOFError, KeyboardInterrupt):
|
|
answer = "n"
|
|
if answer not in ("", "y", "yes"):
|
|
console.print("Cancelled. Nothing was updated.")
|
|
return
|
|
|
|
outcomes = []
|
|
for row in plan.movable:
|
|
console.print(f"\n[bold]── {row.name}[/bold]")
|
|
outcomes.append((row.name, *_update_one(row, console, interactive=tty)))
|
|
|
|
console.print("\n[bold]Summary[/bold]")
|
|
marks = {"updated": "[green]✓ updated[/green]", "current": "[dim]= already current[/dim]",
|
|
"failed": "[red]✗ failed[/red]"}
|
|
for name, status, detail in outcomes:
|
|
console.print(f" {marks[status]} {escape(name)}" + (f" [dim]{escape(detail)}[/dim]" if detail else ""),
|
|
highlight=False)
|
|
if any(status == "failed" for _, status, _ in outcomes):
|
|
sys.exit(1)
|