refactor(hermes_cli): AST-neutral layout compaction of update_cmd*/uninstall (hug brackets, pack args)

This commit is contained in:
Teknium
2026-09-02 20:27:53 -07:00
parent 113f04616b
commit adba16445a
5 changed files with 203 additions and 526 deletions
+15 -38
View File
@@ -133,8 +133,7 @@ def remove_wrapper_script():
candidates = (
bin_dir / name
for bin_dir in (Path.home() / ".local" / "bin", Path("/usr/local/bin"))
for name in ("hermes", "hermes-acp", "hermes-agent")
)
for name in ("hermes", "hermes-acp", "hermes-agent"))
return _remove_each((w for w in candidates if w.exists()), _unlink_ours)
@@ -220,10 +219,7 @@ def uninstall_gateway_service():
def _remove_systemd_gateway() -> bool:
"""Linux: uninstall systemd services (both user and system scopes)."""
from hermes_cli.gateway import (
get_systemd_unit_path,
get_service_name,
_systemctl_cmd,
)
get_systemd_unit_path, get_service_name, _systemctl_cmd)
svc_name = get_service_name()
removed_any = False
@@ -254,8 +250,7 @@ def _remove_launchd_gateway() -> bool:
plist_path = get_launchd_plist_path()
if not plist_path.exists():
return False
subprocess.run(["launchctl", "unload", str(plist_path)],
capture_output=True, check=False)
subprocess.run(["launchctl", "unload", str(plist_path)], capture_output=True, check=False)
plist_path.unlink()
log_success(f"Removed macOS gateway service ({plist_path})")
return True
@@ -290,9 +285,7 @@ def _remove_windows_gateway() -> bool:
_GATEWAY_SERVICE_REMOVERS = {
"Linux": (_remove_systemd_gateway, "Could not check systemd gateway services"),
"Darwin": (_remove_launchd_gateway, "Could not remove launchd gateway service"),
"Windows": (_remove_windows_gateway, "Could not check Windows gateway service"),
}
"Windows": (_remove_windows_gateway, "Could not check Windows gateway service")}
# ============================================================================
# Windows-specific uninstall helpers
@@ -493,11 +486,8 @@ def _uninstall_profile(profile) -> None:
for subcmd in ("stop", "uninstall"):
try:
subprocess.run(
hermes_invocation + ["gateway", subcmd],
capture_output=True,
text=True, encoding='utf-8', errors='replace',
timeout=60,
check=False,
hermes_invocation + ["gateway", subcmd], capture_output=True, text=True,
encoding='utf-8', errors='replace', timeout=60, check=False,
)
except subprocess.TimeoutExpired:
log_warn(f" Gateway {subcmd} timed out for '{name}'")
@@ -525,10 +515,7 @@ def run_gui_uninstall(args):
config/sessions/.env, and never the Python agent or its venv.
"""
from hermes_cli.gui_uninstall import (
agent_is_installed,
gui_install_summary,
uninstall_gui,
)
agent_is_installed, gui_install_summary, uninstall_gui)
hermes_home = get_hermes_home()
summary = gui_install_summary(hermes_home)
@@ -586,8 +573,7 @@ def run_uninstall(args):
_print_uninstall_dry_run(
project_root=project_root,
hermes_home=hermes_home,
full_uninstall=bool(getattr(args, "full", False)),
)
full_uninstall=bool(getattr(args, "full", False)))
return
# Detect named profiles when uninstalling from the default root —
@@ -604,10 +590,8 @@ def run_uninstall(args):
# lite/full modes.
if bool(getattr(args, "yes", False)):
_perform_uninstall(
project_root=project_root,
hermes_home=hermes_home,
full_uninstall=bool(getattr(args, "full", False)),
remove_profiles=False,
project_root=project_root, hermes_home=hermes_home,
full_uninstall=bool(getattr(args, "full", False)), remove_profiles=False,
named_profiles=named_profiles,
)
return
@@ -684,11 +668,8 @@ def run_uninstall(args):
return
_perform_uninstall(
project_root=project_root,
hermes_home=hermes_home,
full_uninstall=full_uninstall,
remove_profiles=remove_profiles,
named_profiles=named_profiles,
project_root=project_root, hermes_home=hermes_home, full_uninstall=full_uninstall,
remove_profiles=remove_profiles, named_profiles=named_profiles,
)
@@ -744,8 +725,7 @@ def _perform_uninstall(
hermes_home: Path,
full_uninstall: bool,
remove_profiles: bool,
named_profiles: list,
) -> None:
named_profiles: list) -> None:
"""Execute the uninstall steps; shared by the interactive and ``--yes`` paths.
Order: stop gateway -> strip PATH (rc files + Windows registry) -> remove wrapper and node
@@ -813,8 +793,7 @@ def _perform_uninstall(
_remove_step(
"Removing Windows installer artifacts (PortableGit, Node, gateway-service)...",
lambda: remove_portable_tooling_windows(hermes_home), "Removed {}",
"No Windows installer artifacts to remove",
)
"No Windows installer artifacts to remove")
# 5. Optionally remove ~/.hermes/ data directory (and named profiles)
if full_uninstall:
@@ -877,9 +856,7 @@ def main(argv=None) -> int:
parser = argparse.ArgumentParser(prog="python -m hermes_cli.uninstall")
parser.add_argument(
"--mode",
choices=["gui", "lite", "full"],
required=True,
"--mode", choices=["gui", "lite", "full"], required=True,
help="gui = Chat GUI only; lite = GUI + agent, keep data; full = everything",
)
args = _UninstallArgs(mode=parser.parse_args(argv).mode)
+15 -39
View File
@@ -63,8 +63,7 @@ def _surviving_pre_update_serve_runtimes(plan) -> list[dict]:
live: dict[int, float | None] = {
entry["pid"]: _numeric(entry.get("create_time"))
for entry in ledger_entries()
if entry.get("purpose") in ("serve", "dashboard") and isinstance(entry.get("pid"), int)
}
if entry.get("purpose") in ("serve", "dashboard") and isinstance(entry.get("pid"), int)}
except Exception as exc:
logger.debug("Serve/dashboard survivor probe failed: %s", exc)
live = None
@@ -77,8 +76,7 @@ def _surviving_pre_update_serve_runtimes(plan) -> list[dict]:
if (
planned_created is not None
and live_created is not None
and abs(float(live_created) - float(planned_created)) >= 2.0
):
and abs(float(live_created) - float(planned_created)) >= 2.0):
# Same number, different process: the pre-update runtime is gone
# and something new registered under its PID. Not a survivor.
continue
@@ -116,8 +114,7 @@ def _recover_gateway_restart_after_abort(
*,
gateway_mode: bool,
skip_profiles: set[str] | None = None,
skip_units: set[str] | None = None,
) -> dict[str, list]:
skip_units: set[str] | None = None) -> dict[str, list]:
"""Retry supervised gateway restarts from a clean Python process.
``hermes update`` normally performs the fleet restart in the interpreter that started before
@@ -139,8 +136,7 @@ def _recover_gateway_restart_after_abort(
"relaunch_attempted": relaunch_attempted,
"failed": failed,
"skipped": skipped,
"serve_units": dict(_empty_serve) if serve_units is None else serve_units,
}
"serve_units": dict(_empty_serve) if serve_units is None else serve_units}
if not profiles and not recover_serve:
return _result([], [], [], [])
@@ -172,11 +168,7 @@ def _recover_gateway_restart_after_abort(
"profiles": profiles,
"supervisors": candidates,
"serve_units": {
"recover": recover_serve,
"skip": _qualified_serve_skips(skip_units),
},
}
),
"recover": recover_serve, "skip": _qualified_serve_skips(skip_units)}}),
"capture_output": True,
"text": True,
"encoding": "utf-8",
@@ -186,13 +178,11 @@ def _recover_gateway_restart_after_abort(
# Gateway profiles run sequentially at up to 90s each; the serve pass
# adds its own restart + settle budget on top, so give the child room
# for both rather than killing a recovery that was working.
"timeout": max(180, 30 + 90 * len(profiles) + (150 if recover_serve else 0)),
}
"timeout": max(180, 30 + 90 * len(profiles) + (150 if recover_serve else 0))}
if sys.platform == "win32":
kwargs["creationflags"] = (
getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0)
| getattr(subprocess, "DETACHED_PROCESS", 0)
)
| getattr(subprocess, "DETACHED_PROCESS", 0))
else:
kwargs["start_new_session"] = True
@@ -222,14 +212,9 @@ def _recover_gateway_restart_after_abort(
and isinstance(raw_serve.get("verified"), list)
and isinstance(raw_serve.get("failed"), list)
and all(
isinstance(unit, str)
for unit in (*raw_serve["verified"], *raw_serve["failed"])
)
):
isinstance(unit, str) for unit in (*raw_serve["verified"], *raw_serve["failed"]))):
serve_units = {
"verified": sorted(raw_serve["verified"]),
"failed": sorted(raw_serve["failed"]),
}
"verified": sorted(raw_serve["verified"]), "failed": sorted(raw_serve["failed"])}
elif recover_serve:
# An unreadable serve block cannot be read as "nothing to do": the
# units it describes are exactly the ones that host tui_gateway and
@@ -245,8 +230,7 @@ def _recover_gateway_restart_after_abort(
not all(isinstance(bucket, list) for bucket in buckets)
or any(not isinstance(profile, str) for profile in reported)
or set(reported) != set(profiles)
or len(reported) != len(set(reported))
):
or len(reported) != len(set(reported))):
logger.warning("Fresh gateway restart recovery returned incomplete profiles")
return _all_failed()
@@ -256,8 +240,7 @@ def _recover_gateway_restart_after_abort(
(relaunch_attempted, " ⚠ Relaunch attempted in a fresh process but not"
" supervisor-verified (check these gateways manually): "),
(serve_units["verified"], " ✓ Restarted serve unit(s) in a fresh process (new main PID observed): "),
(serve_units["failed"], " ⚠ Could not verify a replacement for serve unit(s): "),
):
(serve_units["failed"], " ⚠ Could not verify a replacement for serve unit(s): ")):
if names:
print(text + ", ".join(names))
return _result(profiles, verified, relaunch_attempted, failed, serve_units)
@@ -275,27 +258,20 @@ def _warn_stale_serve_runtimes(rows) -> None:
return
print(
" ⚠ These serve/dashboard processes still run pre-update code"
" (they started before the checkout changed):"
)
" (they started before the checkout changed):")
for row in rows:
supervisor = row.get("supervisor") or "unknown"
print(
f" pid {row.get('pid')} — {row.get('kind')}"
f" (profile {row.get('profile') or 'default'}, {supervisor})"
)
f" (profile {row.get('profile') or 'default'}, {supervisor})")
print(
" Restart them before using Hermes again, e.g."
" `systemctl --user restart hermes-serve.service`"
" or by relaunching `hermes serve` / the Desktop app."
)
" or by relaunching `hermes serve` / the Desktop app.")
def _abort_recovery_is_complete(
*,
planned_gateway_profiles,
covered_gateway_profiles,
recovery_result,
stale_runtime_rows,
*, planned_gateway_profiles, covered_gateway_profiles, recovery_result, stale_runtime_rows
) -> bool:
"""May a fresh-process recovery clear the incomplete flag?
+108 -282
View File
@@ -27,8 +27,7 @@ from hermes_constants import get_default_hermes_root, venv_python_path
from hermes_cli.update_abort_recovery import ( # noqa: F401
_abort_recovery_is_complete, _qualified_serve_skips, _recover_gateway_restart_after_abort,
_serve_unit_recovery_available, _surviving_pre_update_serve_runtimes,
_warn_stale_serve_runtimes,
)
_warn_stale_serve_runtimes)
# Re-exports from the split modules: every moved name stays reachable (and monkeypatchable)
# as ``hermes_cli.update_cmd.<name>``; the split modules import origin-internal names lazily.
from hermes_cli.update_cmd_windows import ( # noqa: F401
@@ -45,8 +44,7 @@ from hermes_cli.update_cmd_windows import ( # noqa: F401
_resume_windows_gateways_and_merge_outcome, _self_and_non_gateway_ancestor_pids,
_serve_relaunch_commands, _start_windows_gateway_service, _stop_process_trees,
_stop_windows_gateway_service, _venv_launcher_ancestors,
_wait_for_windows_update_gateway_exit, _write_update_planned_stop_marker,
)
_wait_for_windows_update_gateway_exit, _write_update_planned_stop_marker)
from hermes_cli.update_cmd_fleet import ( # noqa: F401
_FLEET_RESTART_PENDING_NAME, _FRESH_RESTART_SUPERVISORS, _GatewayRestartOutcome,
_apply_pending_fleet_restart_catchup, _clear_fleet_restart_pending_marker,
@@ -63,25 +61,21 @@ from hermes_cli.update_cmd_fleet import ( # noqa: F401
_wait_for_service_active, _warn_gateway_restart_phase_aborted,
_warn_incomplete_gateway_fleet_restart, _warn_pending_fleet_restart,
_warn_pending_fleet_restart_on_startup, _write_fleet_restart_pending_marker,
_write_gateway_update_exit_code,
)
_write_gateway_update_exit_code)
from hermes_cli.update_cmd_zip import ( # noqa: F401
_ZIP_PRESERVED_TOP_LEVEL, _ZIP_STAGING_ARTIFACT_SUFFIXES, _abort_zip_update_if_dirty_tree,
_atomic_replace_dir, _commit_staged_replacements, _discard_staged,
_is_zip_preserved_entry_status_line, _is_zip_staging_artifact_status_line, _stage_replacement,
_update_via_zip, _zip_overlay_block_reason,
)
_update_via_zip, _zip_overlay_block_reason)
from hermes_cli.update_cmd_stash import ( # noqa: F401
_AUTOSTASH_NAME_PREFIX, _AUTOSTASH_WARN_AGE_DAYS, _discard_stashed_changes,
_git_untracked_paths, _park_stashed_changes, _print_stash_cleanup_guidance,
_reject_unsafe_stash_restore, _resolve_stash_selector, _restore_stashed_changes,
_restored_python_paths, _stash_apply_failed_only_on_existing_untracked,
_stash_local_changes_if_needed, _warn_orphaned_update_autostashes,
)
_stash_local_changes_if_needed, _warn_orphaned_update_autostashes)
from hermes_cli.update_cmd_config import ( # noqa: F401
_LAST_SIBLING_SNAPSHOTS, _check_and_apply_config_migration, _migrate_sibling_profile_configs,
_print_items, _reload_config_modules, _run_config_check_fresh, _run_migrate_config_fresh,
)
_print_items, _reload_config_modules, _run_config_check_fresh, _run_migrate_config_fresh)
from hermes_cli.update_cmd_deps import ( # noqa: F401
_INSTALL_DEFINING_FILES, _SELF_LOCKING_NATIVE_MODULES, _UPDATE_CRITICAL_MODULES,
_abort_dependency_sync_if_self_locked, _capture_active_lazy_features,
@@ -96,8 +90,7 @@ from hermes_cli.update_cmd_deps import ( # noqa: F401
_sync_python_dependencies_after_pull, _update_node_dependencies,
_upgrade_pip_before_lazy_refresh, _validate_critical_modules_import,
_venv_core_imports_healthy, _venv_foreign_owned_paths, _web_build_toolchain_ready,
_web_toolchain_roots,
)
_web_toolchain_roots)
from hermes_cli.update_cmd_git import ( # noqa: F401
OFFICIAL_REPO_URL, OFFICIAL_REPO_URLS, SKIP_UPSTREAM_PROMPT_FILE, _ORPHAN_RESCUE_REFS_TO_KEEP,
_ORPHAN_RESCUE_REF_MAX_AGE_DAYS, _add_upstream_remote, _assess_parked_branch_switch,
@@ -107,8 +100,7 @@ from hermes_cli.update_cmd_git import ( # noqa: F401
_normalize_managed_eol, _portable_git_candidates, _print_fetch_failure,
_print_parked_branch_kept_notice, _print_parked_branch_skip_warning,
_prune_orphan_rescue_refs, _should_skip_upstream_prompt, _sync_fork_with_upstream,
_sync_with_upstream_if_needed,
)
_sync_with_upstream_if_needed)
from hermes_cli.update_cmd_maint import ( # noqa: F401
_PRE_UPDATE_SNAPSHOT_KEEP, _PRE_UPDATE_SNAPSHOT_MAX_FILE_SIZE, _STALE_PURGE_PREFIXES,
_STALE_PURGE_PROTECTED, _UPDATE_RUNTIME_RELOAD_MODULES, _clear_stale_sqlite_sidecars,
@@ -121,8 +113,7 @@ from hermes_cli.update_cmd_maint import ( # noqa: F401
_resolve_pre_update_backup_mode, _restore_state_db_from_snapshot,
_run_post_update_maintenance, _run_pre_update_backup, _sweep_bytecode_after_update,
_update_complete_message, _verify_and_restore_one_state_db,
_verify_and_restore_state_dbs_post_update,
)
_verify_and_restore_state_dbs_post_update)
logger = logging.getLogger(__name__)
@@ -146,14 +137,8 @@ def _no_prompt_git_kwargs() -> dict:
# CLI-startup imports (+ web_server.py, the desktop backend a fresh Windows install
# launches) that must parse post-update; the syntax guard auto-rolls-back on failure.
_UPDATE_CRITICAL_FILES = (
"hermes_cli/main.py",
"hermes_cli/config.py",
"hermes_cli/__init__.py",
"hermes_cli/web_server.py",
"cli.py",
"run_agent.py",
"model_tools.py",
"toolsets.py",
"hermes_cli/main.py", "hermes_cli/config.py", "hermes_cli/__init__.py",
"hermes_cli/web_server.py", "cli.py", "run_agent.py", "model_tools.py", "toolsets.py",
"hermes_constants.py",
)
@@ -170,11 +155,8 @@ def _git_run(git_cmd, args, cwd=None, *, check=False, network=False):
"""Run git capturing utf-8 text (default cwd: checkout); ``network=True`` disables the
terminal prompt so an HTTP 401 fails fast instead of hanging."""
return subprocess.run(
git_cmd + args,
cwd=_m().PROJECT_ROOT if cwd is None else cwd,
capture_output=True,
text=True, encoding="utf-8", errors="replace",
check=check,
git_cmd + args, cwd=_m().PROJECT_ROOT if cwd is None else cwd, capture_output=True,
text=True, encoding="utf-8", errors="replace", check=check,
**(_no_prompt_git_kwargs() if network else {}),
)
@@ -189,8 +171,7 @@ def _capture_head_sha(git_cmd, cwd) -> str | None:
def _validate_python_files_syntax(
root, relpaths
) -> tuple[bool, str | None, str | None]:
root, relpaths) -> tuple[bool, str | None, str | None]:
"""Compile *relpaths* under *root* without writing bytecode into the tree."""
import py_compile
import tempfile
@@ -280,8 +261,7 @@ def _called_process_error_is_git(exc: subprocess.CalledProcessError) -> bool:
def _called_process_error_is_python_dep_install(
exc: subprocess.CalledProcessError,
) -> bool:
exc: subprocess.CalledProcessError) -> bool:
"""True when the failed subprocess was a uv/pip (or ensurepip) install."""
parts = [part.lower() for part in _called_process_error_cmd_parts(exc)]
if not parts:
@@ -290,8 +270,7 @@ def _called_process_error_is_python_dep_install(
if "ensurepip" in parts:
return True
if "install" in parts and (
"pip" in parts or exe in {"pip", "pip.exe", "pip3", "pip3.exe", "uv", "uv.exe"}
):
"pip" in parts or exe in {"pip", "pip.exe", "pip3", "pip3.exe", "uv", "uv.exe"}):
return True
return False
@@ -346,13 +325,11 @@ def _should_zip_fallback_on_update_error(exc: BaseException) -> bool:
return (
isinstance(exc, subprocess.CalledProcessError)
and _m()._is_windows()
and _called_process_error_is_git(exc)
)
and _called_process_error_is_git(exc))
def _print_called_process_error_tail(
exc: subprocess.CalledProcessError, *, limit: int = 12
) -> None:
exc: subprocess.CalledProcessError, *, limit: int = 12) -> None:
"""Print a captured stderr/stdout tail when the failing call recorded one."""
blob = exc.stderr or exc.stdout or ""
if isinstance(blob, bytes):
@@ -405,8 +382,7 @@ def _write_lazy_refresh_incomplete_marker() -> None:
def _format_concurrent_instances_message(
matches: list[tuple[int, str]], scripts_dir: Path
) -> str:
matches: list[tuple[int, str]], scripts_dir: Path) -> str:
"""Build a human-readable explanation + remediation hint for the user."""
shim = scripts_dir / "hermes.exe"
lines = ["✗ Another hermes.exe is running:"]
@@ -457,8 +433,7 @@ def _classify_concurrent_instance(pid: int) -> str:
def _filter_non_gateway_concurrent_instances(
matches: list[tuple[int, str]],
) -> list[tuple[int, str]]:
matches: list[tuple[int, str]]) -> list[tuple[int, str]]:
"""Drop gateway matches (the pause + post-update restart machinery handles them);
anything else (TUI, Desktop backend child, another REPL) has no pause path, so the gate aborts."""
non_gateway: list[tuple[int, str]] = []
@@ -486,15 +461,8 @@ def _run_logged_subprocess(cmd, *, cwd=None, env=None):
"""Run ``cmd`` with combined output captured into update.log only; returns the
``CompletedProcess`` so the caller can surface the output on failure."""
result = subprocess.run(
cmd,
cwd=cwd,
env=env,
check=False,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
text=True,
encoding="utf-8",
errors="replace",
cmd, cwd=cwd, env=env, check=False, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
text=True, encoding="utf-8", errors="replace",
)
_log_only_write(result.stdout or "")
return result
@@ -507,9 +475,7 @@ def _cmd_update_check(branch: str = "main", *, branch_explicit: bool = False):
# Same marker-first admission gate as the apply path, so --check never reports git
# state for an install whose real update mechanism is an image pull.
from hermes_cli.update_contract import (
evaluate_update_admission,
record_refusal_receipt,
)
evaluate_update_admission, record_refusal_receipt)
refusal = evaluate_update_admission(_m().PROJECT_ROOT)
if refusal is not None:
@@ -543,9 +509,7 @@ def _cmd_update_check(branch: str = "main", *, branch_explicit: bool = False):
# checkouts are shallow: a plain fetch would unshallow them and rev-list would report a
# bogus huge "behind" count, so fetch --depth 1 and report presence-only.
is_shallow = (
_git_run(git_cmd, ["rev-parse", "--is-shallow-repository"]).stdout.strip()
== "true"
)
_git_run(git_cmd, ["rev-parse", "--is-shallow-repository"]).stdout.strip() == "true")
depth_args = ["--depth", "1"] if is_shallow else []
if branch == "main":
@@ -622,8 +586,7 @@ def _repair_current_checkout(
active_lazy_features,
active_tool_dependencies,
upstream_checked,
_windows_gateway_resume,
) -> bool:
_windows_gateway_resume) -> bool:
"""Already-up-to-date path: keep the managed runtime current, repair a broken venv.
Returns whether the checkout can be reported complete."""
# "No new commits" != safe interpreter: uv can keep the same CPython patch while
@@ -657,10 +620,7 @@ def _repair_current_checkout(
repair_uv = ensure_uv()
# Venv gone entirely (repair interrupted after the old one was moved aside): recreate.
venv_python_missing = not (
venv_python_path(
_m().PROJECT_ROOT / "venv", windows=_m()._is_windows()
)
).exists()
venv_python_path(_m().PROJECT_ROOT / "venv", windows=_m()._is_windows())).exists()
if venv_python_missing and repair_uv:
print("→ Recreating virtual environment...")
subprocess.run([repair_uv, "venv", "venv"], cwd=_m().PROJECT_ROOT, check=False)
@@ -671,30 +631,18 @@ def _repair_current_checkout(
repair_env = managed_python_env()
repair_env["VIRTUAL_ENV"] = str(_m().PROJECT_ROOT / "venv")
_m()._install_python_dependencies_with_optional_fallback(
[repair_uv, "pip"], env=repair_env, group="all"
)
[repair_uv, "pip"], env=repair_env, group="all")
_m()._refresh_active_lazy_features(
[repair_uv, "pip"],
env=repair_env,
features=active_lazy_features,
)
[repair_uv, "pip"], env=repair_env, features=active_lazy_features)
_m()._restore_active_tool_dependencies(
active_tool_dependencies,
[repair_uv, "pip"],
env=repair_env,
)
active_tool_dependencies, [repair_uv, "pip"], env=repair_env)
else:
_m()._install_python_dependencies_with_optional_fallback(
[sys.executable, "-m", "pip"], group="all"
)
[sys.executable, "-m", "pip"], group="all")
_m()._refresh_active_lazy_features(
[sys.executable, "-m", "pip"],
features=active_lazy_features,
)
[sys.executable, "-m", "pip"], features=active_lazy_features)
_m()._restore_active_tool_dependencies(
active_tool_dependencies,
[sys.executable, "-m", "pip"],
)
active_tool_dependencies, [sys.executable, "-m", "pip"])
_m()._clear_update_incomplete_marker()
healthy_after, detail_after = _venv_core_imports_healthy()
if healthy_after:
@@ -702,20 +650,16 @@ def _repair_current_checkout(
_check_and_apply_config_migration(
assume_yes=assume_yes,
gateway_mode=gateway_mode,
pre_update_snapshot_id=pre_update_snapshot_id,
)
pre_update_snapshot_id=pre_update_snapshot_id)
# The hand-off child never reaches the commits-pulled rebuild; do it here.
if _rebuild_desktop_after_update(
desktop_dir,
had_desktop_app_before_update=had_desktop_app_before_update,
):
desktop_dir, had_desktop_app_before_update=had_desktop_app_before_update):
current_checkout_complete = _print_verified_update_completion("✓ Update complete!")
else:
current_checkout_complete = False
_print_update_completion(
"⚠ Update partially complete — the desktop app was "
"not rebuilt and is still on the previous build."
)
"not rebuilt and is still on the previous build.")
else:
current_checkout_complete = False
print(f"⚠ Venv still unhealthy after repair: {detail_after}")
@@ -729,17 +673,14 @@ def _repair_current_checkout(
completion_message=(
"✓ Already up to date!"
if upstream_checked
else "✓ Up to date with your fork (official repo not checked)."
),
had_desktop_app_before_update=had_desktop_app_before_update,
)
else "✓ Up to date with your fork (official repo not checked)."),
had_desktop_app_before_update=had_desktop_app_before_update)
if runtime_repaired is not None and not _m()._is_windows():
print()
print("⚠ Restart required to finish the managed Python runtime repair.")
print(
" Any running Hermes gateways, Desktop backends, or other "
"long-lived processes still use the previous runtime."
)
"long-lived processes still use the previous runtime.")
print(" Restart each of them to pick up the repaired runtime.")
return current_checkout_complete
@@ -753,32 +694,25 @@ def _reconcile_diverged_checkout(git_cmd, branch: str, pre_pull_sha) -> None:
if _cur_branch and _cur_branch != branch:
print(
f" ⚠ Checkout is on custom branch '{_cur_branch}' — "
f"merging origin/{branch} instead of resetting so local commits survive..."
)
f"merging origin/{branch} instead of resetting so local commits survive...")
# Best-effort safety tag as a recovery anchor.
subprocess.run(
git_cmd
+ ["tag", f"pre-update-{_time.strftime('%Y%m%d-%H%M%S')}"],
cwd=_m().PROJECT_ROOT,
capture_output=True,
check=False,
)
check=False)
merge_result = _git_run(git_cmd, ["merge", "--no-edit", f"origin/{branch}"])
if merge_result.returncode != 0:
subprocess.run(
git_cmd + ["merge", "--abort"],
cwd=_m().PROJECT_ROOT,
capture_output=True,
git_cmd + ["merge", "--abort"], cwd=_m().PROJECT_ROOT, capture_output=True,
check=False,
)
print(
"✗ Merge conflict between local commits and upstream — "
"update stopped, nothing was changed."
)
"update stopped, nothing was changed.")
print(
f" Resolve manually: cd {_m().PROJECT_ROOT} && "
f"git merge origin/{branch}"
)
f" Resolve manually: cd {_m().PROJECT_ROOT} && " f"git merge origin/{branch}")
print(" Then re-run the update. Local work is untouched.")
sys.exit(1)
else:
@@ -787,9 +721,7 @@ def _reconcile_diverged_checkout(git_cmd, branch: str, pre_pull_sha) -> None:
# lose the whole local graph, so park pre_pull_sha behind a rescue ref first.
merge_base_result = _git_run(git_cmd, ["merge-base", "HEAD", f"origin/{branch}"])
has_common_ancestor = bool(
merge_base_result.returncode == 0
and merge_base_result.stdout.strip()
)
merge_base_result.returncode == 0 and merge_base_result.stdout.strip())
if not has_common_ancestor and pre_pull_sha:
from datetime import datetime as _dt, timezone
@@ -797,8 +729,7 @@ def _reconcile_diverged_checkout(git_cmd, branch: str, pre_pull_sha) -> None:
rescue_ref = (
f"refs/hermes-update-backups/orphan-{branch}-"
f"{_dt.now(timezone.utc).strftime('%Y%m%d-%H%M%S')}"
f"-{pre_pull_sha[:12]}"
)
f"-{pre_pull_sha[:12]}")
update_ref_result = _git_run(git_cmd, ["update-ref", rescue_ref, pre_pull_sha])
if update_ref_result.returncode == 0:
print(
@@ -806,8 +737,7 @@ def _reconcile_diverged_checkout(git_cmd, branch: str, pre_pull_sha) -> None:
f"origin/{branch} (orphan divergence) — backed up "
f"current HEAD to {rescue_ref} before resetting. "
f"This backup expires after "
f"{_ORPHAN_RESCUE_REF_MAX_AGE_DAYS} days."
)
f"{_ORPHAN_RESCUE_REF_MAX_AGE_DAYS} days.")
else:
# update-ref failure is intentionally non-fatal, but never claim a backup exists.
print(
@@ -815,12 +745,9 @@ def _reconcile_diverged_checkout(git_cmd, branch: str, pre_pull_sha) -> None:
f"origin/{branch} (orphan divergence) — attempted "
f"to back up current HEAD to {rescue_ref} before "
"resetting, but the backup write failed "
f"(pre-reset SHA was {pre_pull_sha})."
)
f"(pre-reset SHA was {pre_pull_sha}).")
_prune_orphan_rescue_refs(git_cmd, _m().PROJECT_ROOT, branch)
print(
" ⚠ Fast-forward not possible (history diverged), resetting to match remote..."
)
print(" ⚠ Fast-forward not possible (history diverged), resetting to match remote...")
reset_result = _git_run(git_cmd, ["reset", "--hard", f"origin/{branch}"])
if reset_result.returncode != 0:
print(f"✗ Failed to reset to origin/{branch}.")
@@ -870,8 +797,7 @@ def _pull_updates(
prompt_for_restore,
gw_input_fn,
discard_local_changes,
keep_stash,
):
keep_stash):
"""Fast-forward onto ``origin/<branch>`` and settle the autostash. Divergence by shape:
custom branch -> merge, same branch -> reset, orphan history -> rescue ref first; a
post-pull syntax error in a critical file rolls back. Exits on failure; returns pre-pull SHA."""
@@ -906,8 +832,7 @@ def _pull_updates(
_m().PROJECT_ROOT,
auto_stash_ref,
prompt_user=prompt_for_restore,
input_fn=gw_input_fn,
)
input_fn=gw_input_fn)
return pre_pull_sha
@@ -944,21 +869,14 @@ def _apply_parked_branch_guard(
in_place_update = False
if current_branch != branch and current_branch != "HEAD":
switch_safe, switch_block_reason = _m()._assess_parked_branch_switch(
git_cmd, _m().PROJECT_ROOT, current_branch, branch
)
git_cmd, _m().PROJECT_ROOT, current_branch, branch)
if not switch_safe:
_m()._print_parked_branch_skip_warning(
git_cmd,
_m().PROJECT_ROOT,
current_branch,
branch,
switch_block_reason,
)
git_cmd, _m().PROJECT_ROOT, current_branch, branch, switch_block_reason)
print()
print(
"⚠ Update finished — code update SKIPPED"
f"{_branch_head_suffix(git_cmd, _m().PROJECT_ROOT)}"
)
f"{_branch_head_suffix(git_cmd, _m().PROJECT_ROOT)}")
_m()._resume_windows_gateways_after_update(_windows_gateway_resume)
sys.exit(1)
if switch_block_reason.startswith("unmerged:"):
@@ -970,8 +888,7 @@ def _apply_parked_branch_guard(
_in_place_configured = (
isinstance(_upd_cfg, dict)
and _upd_cfg.get("parked_branch_strategy", "switch")
== "update_in_place"
)
== "update_in_place")
if _in_place_configured and not switch_branch:
# --branch typos used to surface via the checkout failing, which this path skips.
verify_ref = _git_run(git_cmd, ["rev-parse", "--verify", "--quiet", f"origin/{branch}"])
@@ -981,21 +898,16 @@ def _apply_parked_branch_guard(
in_place_update = True
print(
f" ℹ On branch '{current_branch}' — updating it in place from "
f"origin/{branch} (no branch switch; local commits preserved)."
)
f"origin/{branch} (no branch switch; local commits preserved).")
else:
parked_branch_switched = True
_m()._print_parked_branch_kept_notice(
current_branch,
branch,
switch_block_reason.split(":", 1)[1],
)
current_branch, branch, switch_block_reason.split(":", 1)[1])
else:
parked_branch_switched = True
print(
f" ⚠ Checkout was parked on '{current_branch}' "
f"(fully merged) — switching back to {branch}..."
)
f"(fully merged) — switching back to {branch}...")
return parked_branch_switched, in_place_update, switch_block_reason
@@ -1009,15 +921,13 @@ def _prepare_checkout_for_update(
gateway_mode,
gw_input_fn,
switch_branch,
_windows_gateway_resume,
):
_windows_gateway_resume):
"""Parked-branch guard, land on the target, stash, count new commits. Exits when the
checkout is unsafe to move or the target is missing. ``commit_count`` is 0 when up to
date, -1 when tips differ but the shallow count is unrecoverable."""
parked_branch_switched, in_place_update, switch_block_reason = _apply_parked_branch_guard(
git_cmd, branch, current_branch, switch_branch=switch_branch,
_windows_gateway_resume=_windows_gateway_resume,
)
_windows_gateway_resume=_windows_gateway_resume)
if not in_place_update and current_branch != branch:
if current_branch == "HEAD":
@@ -1034,8 +944,7 @@ def _prepare_checkout_for_update(
_m().PROJECT_ROOT,
auto_stash_ref,
prompt_user=False,
input_fn=gw_input_fn,
)
input_fn=gw_input_fn)
print(f"✗ Branch '{branch}' does not exist locally or on origin.")
if track_result.stderr.strip():
print(f" {track_result.stderr.strip().splitlines()[0]}")
@@ -1046,8 +955,7 @@ def _prepare_checkout_for_update(
prompt_for_restore = (
auto_stash_ref is not None
and not assume_yes
and (gateway_mode or (sys.stdin.isatty() and sys.stdout.isatty()))
)
and (gateway_mode or (sys.stdin.isatty() and sys.stdout.isatty())))
# On shallow checkouts `rev-list --count` can report the entire remote ancestry. The
# zero/nonzero gate is still sound; treat the shallow NUMBER as unknown and recover it
@@ -1056,9 +964,7 @@ def _prepare_checkout_for_update(
commit_count = int(result.stdout.strip())
apply_is_shallow = (
_git_run(git_cmd, ["rev-parse", "--is-shallow-repository"]).stdout.strip()
== "true"
)
_git_run(git_cmd, ["rev-parse", "--is-shallow-repository"]).stdout.strip() == "true")
if commit_count > 0 and apply_is_shallow:
from hermes_cli.banner import _github_compare_behind
@@ -1075,30 +981,18 @@ def _prepare_checkout_for_update(
if commit_count == 0 and is_fork and branch == "main":
pre_sync_sha = _capture_head_sha(git_cmd, _m().PROJECT_ROOT)
upstream_checked = _m()._sync_with_upstream_if_needed(
git_cmd,
_m().PROJECT_ROOT,
assume_yes=assume_yes,
input_fn=gw_input_fn,
)
git_cmd, _m().PROJECT_ROOT, assume_yes=assume_yes, input_fn=gw_input_fn)
post_sync_sha = _capture_head_sha(git_cmd, _m().PROJECT_ROOT)
if pre_sync_sha and post_sync_sha and pre_sync_sha != post_sync_sha:
synced_count = _count_commits_between(
git_cmd,
_m().PROJECT_ROOT,
pre_sync_sha,
post_sync_sha,
)
git_cmd, _m().PROJECT_ROOT, pre_sync_sha, post_sync_sha)
# HEAD moving is proof of an update even if the count can't be read.
commit_count = max(1, synced_count)
return _CheckoutPlan(
auto_stash_ref=auto_stash_ref,
commit_count=commit_count,
in_place_update=in_place_update,
parked_branch_switched=parked_branch_switched,
prompt_for_restore=prompt_for_restore,
switch_block_reason=switch_block_reason,
upstream_checked=upstream_checked,
auto_stash_ref=auto_stash_ref, commit_count=commit_count, in_place_update=in_place_update,
parked_branch_switched=parked_branch_switched, prompt_for_restore=prompt_for_restore,
switch_block_reason=switch_block_reason, upstream_checked=upstream_checked,
)
@@ -1126,10 +1020,7 @@ def _resolve_update_options(args, gateway_mode: bool) -> _UpdateOptions:
# Captured before any pull so the completion line can report the transition.
pre_update_version = _read_project_version()
gw_input_fn = (
(lambda prompt, default="": _gateway_prompt(prompt, default))
if gateway_mode
else None
)
(lambda prompt, default="": _gateway_prompt(prompt, default)) if gateway_mode else None)
assume_yes = bool(getattr(args, "yes", False))
# --keep-stash (desktop updater): never re-apply the autostash; only when an update
# landed — abort/no-op paths still restore since the tree is unchanged.
@@ -1141,10 +1032,7 @@ def _resolve_update_options(args, gateway_mode: bool) -> _UpdateOptions:
# Interactive terminals always stash-and-ask; only non-interactive updates consult
# updates.non_interactive_local_changes (auto-restore vs discard).
_non_interactive_update = (
gateway_mode
or assume_yes
or not (sys.stdin.isatty() and sys.stdout.isatty())
)
gateway_mode or assume_yes or not (sys.stdin.isatty() and sys.stdout.isatty()))
discard_local_changes = False
if _non_interactive_update:
try:
@@ -1160,13 +1048,9 @@ def _resolve_update_options(args, gateway_mode: bool) -> _UpdateOptions:
discard_local_changes = False
return _UpdateOptions(
active_lazy_features=active_lazy_features,
active_tool_dependencies=active_tool_dependencies,
pre_update_version=pre_update_version,
gw_input_fn=gw_input_fn,
assume_yes=assume_yes,
keep_stash=keep_stash,
switch_branch=switch_branch,
discard_local_changes=discard_local_changes,
active_tool_dependencies=active_tool_dependencies, pre_update_version=pre_update_version,
gw_input_fn=gw_input_fn, assume_yes=assume_yes, keep_stash=keep_stash,
switch_branch=switch_branch, discard_local_changes=discard_local_changes,
)
@@ -1185,9 +1069,7 @@ def _begin_update_receipt_and_plan(args):
_pre_update_plan = None
with _best_effort('Update plan phase failed: %s'):
from hermes_cli.update_inventory import (
collect_runtime_inventory,
record_plan_in_receipt,
)
collect_runtime_inventory, record_plan_in_receipt)
_pre_update_plan = collect_runtime_inventory()
record_plan_in_receipt(_pre_update_plan)
@@ -1234,12 +1116,10 @@ def _prepare_git_command() -> tuple[bool, list, bool]:
"windows.appendAtomically=false",
"config",
"windows.appendAtomically",
"false",
],
"false"],
cwd=_m().PROJECT_ROOT,
check=False,
capture_output=True,
)
capture_output=True)
git_cmd = ["git"]
if sys.platform == "win32":
@@ -1275,12 +1155,10 @@ def _verify_head_after_pull(
print("✗ Code did not move — update was a no-op.")
print(
f" HEAD is pinned to {pre_pull_sha[:10]} (detached checkout); "
f"origin/{branch} advanced but the working tree stayed put."
)
f"origin/{branch} advanced but the working tree stayed put.")
print(
" Reattach to the branch and retry: "
f"git -C {_m().PROJECT_ROOT} checkout {branch} && hermes update"
)
f"git -C {_m().PROJECT_ROOT} checkout {branch} && hermes update")
_m()._resume_windows_gateways_after_update(_windows_gateway_resume)
sys.exit(1)
@@ -1288,27 +1166,21 @@ def _verify_head_after_pull(
# legitimate exception (origin/<target> merged INTO the checked-out branch).
post_pull_branch = _git_run(git_cmd, ["rev-parse", "--abbrev-ref", "HEAD"]).stdout.strip()
if (
not in_place_update
and post_pull_branch
and post_pull_branch not in {branch, "HEAD"}
):
not in_place_update and post_pull_branch and post_pull_branch not in {branch, "HEAD"}):
print()
print(
f"✗ Update pulled origin/{branch}, but the checkout is on "
f"'{post_pull_branch}' — not claiming success."
)
f"'{post_pull_branch}' — not claiming success.")
print(
" Switch to the target branch and retry: "
f"git -C {_m().PROJECT_ROOT} checkout {branch} && hermes update"
)
f"git -C {_m().PROJECT_ROOT} checkout {branch} && hermes update")
_m()._resume_windows_gateways_after_update(_windows_gateway_resume)
sys.exit(1)
return post_pull_sha
def _handle_update_called_process_error(
e, args, gateway_mode: bool, had_desktop_app_before_update: bool
) -> None:
e, args, gateway_mode: bool, had_desktop_app_before_update: bool) -> None:
"""Git/installer failure: ZIP-fallback when safe, else report and ``sys.exit(1)``."""
stage = _format_update_failure_stage(e)
if _should_zip_fallback_on_update_error(e):
@@ -1316,9 +1188,7 @@ def _handle_update_called_process_error(
print("→ Falling back to ZIP download...")
print()
desktop_build_ok = _update_via_zip(
args,
had_desktop_app_before_update=had_desktop_app_before_update,
)
args, had_desktop_app_before_update=had_desktop_app_before_update)
if gateway_mode:
_write_gateway_update_exit_code(desktop_build_ok)
else:
@@ -1328,14 +1198,12 @@ def _handle_update_called_process_error(
print(
" The git update already finished. Re-downloading the source "
"ZIP cannot fix a dependency install error and would overwrite "
"local files."
)
"local files.")
if _m()._is_windows():
print(" Retry through the venv interpreter:")
print(
' venv\\Scripts\\python.exe -c '
'"from hermes_cli.main import main; main()" update --yes'
)
'"from hermes_cli.main import main; main()" update --yes')
with suppress(Exception):
from hermes_cli.update_receipt import finalize_update_receipt
@@ -1357,8 +1225,7 @@ def _finish_already_up_to_date(
had_desktop_app_before_update: bool,
active_lazy_features,
active_tool_dependencies,
_windows_gateway_resume,
) -> None:
_windows_gateway_resume) -> None:
""""Already up to date" path: restore stash/branch, repair the checkout, catch up the fleet.
``sys.exit(1)`` when the repair is incomplete (after gateway exit code + partial receipt)."""
auto_stash_ref = _plan.auto_stash_ref
@@ -1376,33 +1243,27 @@ def _finish_already_up_to_date(
_m().PROJECT_ROOT,
auto_stash_ref,
prompt_user=prompt_for_restore,
input_fn=gw_input_fn,
)
input_fn=gw_input_fn)
if parked_branch_switched:
if switch_block_reason.startswith("unmerged:"):
_count = switch_block_reason.split(":", 1)[1]
print(
f" ✓ Checkout was parked on '{current_branch}' — "
f"switched back to {branch}; {_count} unmerged "
f"commit(s) kept on '{current_branch}'."
)
f"commit(s) kept on '{current_branch}'.")
else:
print(
f" ✓ Checkout was parked on '{current_branch}' (fully "
f"merged) — switched back to {branch}."
)
f"merged) — switched back to {branch}.")
elif current_branch not in {branch, "HEAD"}:
_git_run(git_cmd, ["checkout", current_branch])
current_checkout_complete = _repair_current_checkout(
assume_yes=assume_yes,
gateway_mode=gateway_mode,
pre_update_snapshot_id=pre_update_snapshot_id,
desktop_dir=desktop_dir,
assume_yes=assume_yes, gateway_mode=gateway_mode,
pre_update_snapshot_id=pre_update_snapshot_id, desktop_dir=desktop_dir,
had_desktop_app_before_update=had_desktop_app_before_update,
active_lazy_features=active_lazy_features,
active_tool_dependencies=active_tool_dependencies,
upstream_checked=upstream_checked,
active_tool_dependencies=active_tool_dependencies, upstream_checked=upstream_checked,
_windows_gateway_resume=_windows_gateway_resume,
)
_m()._resume_windows_gateways_after_update(_windows_gateway_resume)
@@ -1443,8 +1304,7 @@ def _cmd_update_impl(args, gateway_mode: bool):
_record_update_step(
"pre_update_backup",
pre_update_snapshot_id is not None,
f"snapshot={pre_update_snapshot_id}" if pre_update_snapshot_id else "disabled or failed",
)
f"snapshot={pre_update_snapshot_id}" if pre_update_snapshot_id else "disabled or failed")
_windows_gateway_resume = _m()._pause_windows_gateways_for_update()
if _windows_gateway_resume:
@@ -1472,9 +1332,7 @@ def _cmd_update_impl(args, gateway_mode: bool):
if use_zip_update:
try:
desktop_build_ok = _update_via_zip(
args,
had_desktop_app_before_update=had_desktop_app_before_update,
)
args, had_desktop_app_before_update=had_desktop_app_before_update)
finally:
_m()._resume_windows_gateways_after_update(_windows_gateway_resume)
if gateway_mode:
@@ -1509,14 +1367,8 @@ def _cmd_update_impl(args, gateway_mode: bool):
current_branch = result.stdout.strip()
_plan = _prepare_checkout_for_update(
git_cmd,
branch,
current_branch,
is_fork=is_fork,
assume_yes=assume_yes,
gateway_mode=gateway_mode,
gw_input_fn=gw_input_fn,
switch_branch=switch_branch,
git_cmd, branch, current_branch, is_fork=is_fork, assume_yes=assume_yes,
gateway_mode=gateway_mode, gw_input_fn=gw_input_fn, switch_branch=switch_branch,
_windows_gateway_resume=_windows_gateway_resume,
)
auto_stash_ref = _plan.auto_stash_ref
@@ -1526,15 +1378,9 @@ def _cmd_update_impl(args, gateway_mode: bool):
if commit_count == 0:
_finish_already_up_to_date(
git_cmd,
branch,
current_branch,
_plan,
assume_yes=assume_yes,
gateway_mode=gateway_mode,
gw_input_fn=gw_input_fn,
pre_update_snapshot_id=pre_update_snapshot_id,
desktop_dir=desktop_dir,
git_cmd, branch, current_branch, _plan, assume_yes=assume_yes,
gateway_mode=gateway_mode, gw_input_fn=gw_input_fn,
pre_update_snapshot_id=pre_update_snapshot_id, desktop_dir=desktop_dir,
had_desktop_app_before_update=had_desktop_app_before_update,
active_lazy_features=active_lazy_features,
active_tool_dependencies=active_tool_dependencies,
@@ -1550,22 +1396,15 @@ def _cmd_update_impl(args, gateway_mode: bool):
print("→ Pulling updates...")
pre_pull_sha = _pull_updates(
git_cmd,
branch,
auto_stash_ref,
prompt_for_restore=prompt_for_restore,
gw_input_fn=gw_input_fn,
discard_local_changes=discard_local_changes,
git_cmd, branch, auto_stash_ref, prompt_for_restore=prompt_for_restore,
gw_input_fn=gw_input_fn, discard_local_changes=discard_local_changes,
keep_stash=keep_stash,
)
_invalidate_update_cache()
post_pull_sha = _verify_head_after_pull(
git_cmd,
branch,
pre_pull_sha,
in_place_update=in_place_update,
git_cmd, branch, pre_pull_sha, in_place_update=in_place_update,
_windows_gateway_resume=_windows_gateway_resume,
)
@@ -1579,19 +1418,12 @@ def _cmd_update_impl(args, gateway_mode: bool):
if is_fork and branch == "main":
_m()._sync_with_upstream_if_needed(
git_cmd,
_m().PROJECT_ROOT,
assume_yes=assume_yes,
input_fn=gw_input_fn,
)
git_cmd, _m().PROJECT_ROOT, assume_yes=assume_yes, input_fn=gw_input_fn)
# .[all], falling back to base + extras individually so one broken extra doesn't strip
# the rest; the ownership preflight refuses first on foreign-owned (sudo-pip) venv files.
_sync_python_dependencies_after_pull(
git_cmd,
branch,
pre_pull_sha,
active_lazy_features=active_lazy_features,
git_cmd, branch, pre_pull_sha, active_lazy_features=active_lazy_features,
active_tool_dependencies=active_tool_dependencies,
_windows_gateway_resume=_windows_gateway_resume,
)
@@ -1600,20 +1432,16 @@ def _cmd_update_impl(args, gateway_mode: bool):
_m()._build_web_ui(_m().PROJECT_ROOT / "web")
desktop_build_ok = _rebuild_desktop_after_update(
desktop_dir,
had_desktop_app_before_update=had_desktop_app_before_update,
)
desktop_dir, had_desktop_app_before_update=had_desktop_app_before_update)
print()
print(f"✓ Code updated!{_branch_head_suffix(git_cmd, _m().PROJECT_ROOT)}")
update_complete = _run_post_update_maintenance(
assume_yes=assume_yes,
gateway_mode=gateway_mode,
assume_yes=assume_yes, gateway_mode=gateway_mode,
pre_update_snapshot_id=pre_update_snapshot_id,
had_desktop_app_before_update=had_desktop_app_before_update,
node_failures=node_failures,
desktop_build_ok=desktop_build_ok,
node_failures=node_failures, desktop_build_ok=desktop_build_ok,
pre_update_version=pre_update_version,
)
@@ -1626,10 +1454,8 @@ def _cmd_update_impl(args, gateway_mode: bool):
_restart = _restart_gateway_fleet_after_update(_pre_update_plan, gateway_mode)
_resume_windows_gateways_and_merge_outcome(_restart, _windows_gateway_resume, gateway_mode)
_verify_fleet_after_update(
_restart,
_pre_update_plan=_pre_update_plan,
_windows_gateway_resume=_windows_gateway_resume,
node_failures=node_failures,
_restart, _pre_update_plan=_pre_update_plan,
_windows_gateway_resume=_windows_gateway_resume, node_failures=node_failures,
update_complete=update_complete,
)
+15 -36
View File
@@ -31,8 +31,7 @@ def _reload_config_modules() -> None:
"hermes_cli.config",
"hermes_cli.config_migrations",
"hermes_cli._subprocess_compat",
"hermes_cli.dashboard_procs",
):
"hermes_cli.dashboard_procs"):
mod = sys.modules.get(mod_name)
if mod is not None:
try:
@@ -74,10 +73,7 @@ def _migrate_sibling_profile_configs() -> list[tuple[str, int, int]]:
migrated: list[tuple[str, int, int]] = []
with _best_effort('Sibling profile enumeration failed: %s'):
from hermes_constants import (
get_process_hermes_home,
reset_hermes_home_override,
set_hermes_home_override,
)
get_process_hermes_home, reset_hermes_home_override, set_hermes_home_override)
from hermes_cli.profiles import _get_profiles_root, _PROFILE_ID_RE
active_home = get_process_hermes_home()
@@ -124,8 +120,7 @@ def _restore_snapshot_safety_nets(pre_update_snapshot_id) -> None:
print(
" ⚠️ cron/jobs.json lost jobs during this update — "
f"restored {cron_restore['job_count']} job(s) from "
f"pre-update snapshot {cron_restore['snapshot_id']}."
)
f"pre-update snapshot {cron_restore['snapshot_id']}.")
except Exception as exc:
# Never let the cron safety net break an otherwise-good update.
logger.debug("Cron jobs auto-restore check failed: %s", exc)
@@ -141,8 +136,7 @@ def _restore_snapshot_safety_nets(pre_update_snapshot_id) -> None:
print(
" ⚠️ config.yaml user model settings were rewritten during "
f"this update — restored {', '.join(cfg_restore['keys'])} "
f"from pre-update snapshot {cfg_restore['snapshot_id']}."
)
f"from pre-update snapshot {cfg_restore['snapshot_id']}.")
except Exception as exc:
# Never let the config safety net break an otherwise-good update.
logger.debug("Config model-settings auto-restore check failed: %s", exc)
@@ -152,38 +146,33 @@ def _restore_snapshot_safety_nets(pre_update_snapshot_id) -> None:
from hermes_cli.backup import restore_cron_jobs_all_profiles
for _restored in restore_cron_jobs_all_profiles(
_LAST_SIBLING_SNAPSHOTS
):
_LAST_SIBLING_SNAPSHOTS):
print()
print(
f" ⚠️ Profile '{_restored['profile']}': cron/jobs.json "
f"lost jobs during this update — restored "
f"{_restored['job_count']} job(s) from pre-update "
f"snapshot {_restored['snapshot_id']}."
)
f"snapshot {_restored['snapshot_id']}.")
# Same config model-settings safety net for sibling profiles.
with _best_effort('Sibling config auto-restore check failed: %s'):
from hermes_cli.backup import restore_config_model_settings_all_profiles
for _cfg_restored in restore_config_model_settings_all_profiles(
_LAST_SIBLING_SNAPSHOTS
):
_LAST_SIBLING_SNAPSHOTS):
print()
print(
f" ⚠️ Profile '{_cfg_restored['profile']}': config.yaml "
f"user model settings were rewritten during this update — "
f"restored {', '.join(_cfg_restored['keys'])} from "
f"pre-update snapshot {_cfg_restored['snapshot_id']}."
)
f"pre-update snapshot {_cfg_restored['snapshot_id']}.")
def _check_and_apply_config_migration(
*,
assume_yes: bool = False,
gateway_mode: bool = False,
pre_update_snapshot_id: str | None = None,
) -> None:
pre_update_snapshot_id: str | None = None) -> None:
"""Check/apply config migrations on an update completion path.
Must use freshly-reloaded modules (see ``_reload_config_modules``) and run on EVERY
@@ -195,8 +184,7 @@ def _check_and_apply_config_migration(
_migrate_sibling_profile_configs,
_reload_config_modules,
_run_config_check_fresh,
_run_migrate_config_fresh,
)
_run_migrate_config_fresh)
print()
print("→ Checking configuration for new options...")
@@ -204,9 +192,7 @@ def _check_and_apply_config_migration(
_reload_config_modules()
from hermes_cli.config import (
get_missing_env_vars,
get_missing_config_fields,
)
get_missing_env_vars, get_missing_config_fields)
# A config-check failure must not break an otherwise-successful update.
try:
@@ -257,29 +243,22 @@ def _check_and_apply_config_migration(
elif gateway_mode:
response = (
_gateway_prompt(
"Would you like to configure new options now? [Y/n]", "n"
)
"Would you like to configure new options now? [Y/n]", "n")
.strip()
.lower()
)
.lower())
elif not (sys.stdin.isatty() and sys.stdout.isatty()):
print(" ℹ Non-interactive session — applying safe config migrations.")
response = "auto"
else:
try:
response = (
input("Would you like to configure them now? [Y/n]: ")
.strip()
.lower()
)
response = (input("Would you like to configure them now? [Y/n]: ").strip().lower())
except EOFError:
response = "n"
except UnicodeDecodeError:
# Non-UTF-8 locales / embedded terminals can make input() raise this.
print(
" ⚠ Could not read input (encoding issue). Skipping. "
"Run 'hermes config migrate' manually to configure."
)
"Run 'hermes config migrate' manually to configure.")
response = "n"
if response in {"", "y", "yes", "auto"}:
+50 -131
View File
@@ -19,7 +19,6 @@ from hermes_constants import venv_python_path
# Log-record parity with the origin module.
logger = logging.getLogger("hermes_cli.update_cmd")
# Files defining the editable install; a pull touching none of them cannot invalidate it.
_INSTALL_DEFINING_FILES = "pyproject.toml", "setup.py", "setup.cfg", "MANIFEST.in", "uv.lock"
@@ -42,8 +41,7 @@ def _editable_install_is_current(git_cmd, cwd, pre_pull_sha: str | None) -> bool
+ list(_INSTALL_DEFINING_FILES),
cwd=cwd,
capture_output=True,
text=True, encoding="utf-8", errors="replace",
)
text=True, encoding="utf-8", errors="replace")
except OSError:
return False
if result.returncode != 0:
@@ -57,8 +55,7 @@ _UPDATE_CRITICAL_MODULES = "hermes_cli.main", "run_agent", "model_tools", "tools
def _critical_module_import_failures(
root, *, report_runtime_errors: bool = False
) -> dict[str, tuple[str, str]]:
root, *, report_runtime_errors: bool = False) -> dict[str, tuple[str, str]]:
"""Import each ``_UPDATE_CRITICAL_MODULES`` entry in a subprocess; return failures in probe order.
Syntax validation only *parses*, so a partially-updated tree (reachable via the Windows
@@ -99,9 +96,7 @@ def _critical_module_import_failures(
tuple(sorted(FIRST_PARTY_MODULE_ROOTS)),
report_runtime_errors,
report_runtime_errors,
marker,
)
)
marker))
try:
interpreter = sys.executable
with suppress(Exception):
@@ -109,21 +104,13 @@ def _critical_module_import_failures(
if venv_python.exists():
interpreter = str(venv_python)
result = subprocess.run(
[interpreter, "-c", probe],
cwd=str(root),
capture_output=True,
text=True,
encoding="utf-8",
errors="replace",
timeout=120,
[interpreter, "-c", probe], cwd=str(root), capture_output=True, text=True,
encoding="utf-8", errors="replace", timeout=120,
)
except subprocess.TimeoutExpired:
return {
"critical-module probe": (
"TimeoutExpired",
"timed out before reporting import health",
)
}
"TimeoutExpired", "timed out before reporting import health")}
except (OSError, subprocess.SubprocessError):
# Can't run the probe — don't block the update on our own tooling.
return {}
@@ -133,9 +120,7 @@ def _critical_module_import_failures(
"critical-module probe": (
"ProbeTerminated",
"terminated before reporting import health "
f"(exit code {result.returncode})",
)
}
f"(exit code {result.returncode})")}
try:
import json
@@ -144,22 +129,17 @@ def _critical_module_import_failures(
not isinstance(item, list)
or len(item) != 3
or not all(isinstance(value, str) for value in item)
for item in failures
):
for item in failures):
raise ValueError("invalid import-health payload")
return {str(module): (str(kind), str(detail)) for module, kind, detail in failures}
except (TypeError, ValueError):
return {
"critical-module probe": (
"MalformedPayload",
"reported malformed import health data",
)
"critical-module probe": ( "MalformedPayload", "reported malformed import health data" )
}
def _validate_critical_modules_import(
root, *, report_runtime_errors: bool = False
) -> tuple[bool, str | None, str | None]:
root, *, report_runtime_errors: bool = False) -> tuple[bool, str | None, str | None]:
"""Return the first critical-module import failure, if any."""
failures = _critical_module_import_failures(root, report_runtime_errors=report_runtime_errors)
if failures:
@@ -172,8 +152,7 @@ def _npm_bin_exists(bin_dir: Path, name: str) -> bool:
"""True when an npm bin shim for *name* exists (POSIX or Windows)."""
return any(
(bin_dir / candidate).exists()
for candidate in (name, f"{name}.cmd", f"{name}.ps1", f"{name}.exe")
)
for candidate in (name, f"{name}.cmd", f"{name}.ps1", f"{name}.exe"))
def _web_build_toolchain_ready(*roots: Path) -> bool:
@@ -182,12 +161,9 @@ def _web_build_toolchain_ready(*roots: Path) -> bool:
bin_dirs = [
bin_dir
for bin_dir in (root / "node_modules" / ".bin" for root in roots)
if bin_dir.is_dir()
]
if bin_dir.is_dir()]
return bool(bin_dirs) and all(
any(_npm_bin_exists(bin_dir, tool) for bin_dir in bin_dirs)
for tool in ("tsc", "vite")
)
any(_npm_bin_exists(bin_dir, tool) for bin_dir in bin_dirs) for tool in ("tsc", "vite"))
def _web_toolchain_roots(web_dir: Path) -> tuple[Path, ...]:
@@ -202,32 +178,22 @@ def _ensure_venv_pip(pip_cmd: list, python_exe: str) -> None:
from hermes_cli.update_cmd import _m
try:
subprocess.run(
pip_cmd + ["--version"],
cwd=_m().PROJECT_ROOT,
check=True,
capture_output=True,
)
pip_cmd + ["--version"], cwd=_m().PROJECT_ROOT, check=True, capture_output=True)
except subprocess.CalledProcessError:
subprocess.run(
[python_exe, "-m", "ensurepip", "--upgrade", "--default-pip"],
cwd=_m().PROJECT_ROOT,
check=True,
)
check=True)
def _upgrade_pip_before_lazy_refresh(
install_cmd_prefix: list[str],
*,
env: dict[str, str] | None = None,
) -> None:
install_cmd_prefix: list[str], *, env: dict[str, str] | None = None) -> None:
"""Upgrade pip before lazy refreshes: older pip can fail setuptools source builds and
leave a partially-written venv. Never raises."""
from hermes_cli.update_cmd import _m
try:
_m()._run_package_only_install(
install_cmd_prefix + ["install", "--upgrade", "pip"],
env=env,
)
install_cmd_prefix + ["install", "--upgrade", "pip"], env=env)
except subprocess.CalledProcessError as exc:
logger.debug("pip upgrade before lazy refresh failed: %s", exc)
@@ -255,10 +221,7 @@ def _capture_active_tool_dependencies() -> list[str]:
def _restore_active_tool_dependencies(
dependencies: list[str],
install_cmd_prefix: list[str],
*,
env: dict[str, str] | None = None,
dependencies: list[str], install_cmd_prefix: list[str], *, env: dict[str, str] | None = None
) -> None:
"""Restore allowlisted ``hermes tools`` dependencies (from a pre-rebuild probe) into a rebuilt venv.
Never raises: a failed optional tool must not block the update, but must be reported."""
@@ -287,12 +250,10 @@ def _restore_active_tool_dependencies(
"-c",
"import importlib.util,sys; "
"raise SystemExit(0 if importlib.util.find_spec(sys.argv[1]) else 1)",
module_name,
],
module_name],
capture_output=True,
env=env,
check=False,
)
check=False)
if probe.returncode == 0:
continue
except (subprocess.SubprocessError, OSError):
@@ -310,9 +271,7 @@ def _restore_active_tool_dependencies(
for name, install_args in missing:
try:
_m()._run_package_only_install(
install_cmd_prefix + ["install", *install_args, "--quiet"],
env=env,
)
install_cmd_prefix + ["install", *install_args, "--quiet"], env=env)
restored.append(name)
except Exception as exc:
# Best-effort: surface failures without aborting the update.
@@ -330,8 +289,7 @@ def _refresh_active_lazy_features(
install_cmd_prefix: list[str] | None = None,
*,
env: dict[str, str] | None = None,
features: list[str] | None = None,
) -> bool:
features: list[str] | None = None) -> bool:
"""Refresh previously-activated lazy backends (cold ones untouched) after a code update.
The core install never touches ``lazy_deps`` backends, so a bumped :data:`LAZY_DEPS` pin
@@ -464,10 +422,7 @@ def _is_android_python() -> bool:
def _install_psutil_android_compat(
install_cmd_prefix: list[str],
*,
env: dict[str, str] | None = None,
) -> None:
install_cmd_prefix: list[str], *, env: dict[str, str] | None = None) -> None:
"""Install psutil on Android by patching its platform detection: setup gates Linux sources on
``sys.platform.startswith('linux')`` but Termux reports ``'android'`` though the Linux path
compiles fine. Only this attempt's build tree is patched. Stopgap until psutil PR 2762 ships."""
@@ -483,9 +438,7 @@ def _install_psutil_android_compat(
src_root = prepare_patched_psutil_sdist(archive, tmp_path)
_m()._run_install_with_heartbeat(
install_cmd_prefix + ["install", "--no-build-isolation", str(src_root)],
env=env,
)
install_cmd_prefix + ["install", "--no-build-isolation", str(src_root)], env=env)
def _ensure_uv_for_termux(pip_cmd: list[str]) -> str | None:
@@ -509,8 +462,7 @@ def _ensure_uv_for_termux(pip_cmd: list[str]) -> str | None:
result = subprocess.run(
pip_cmd + ["install", "uv", "--only-binary", ":all:"],
cwd=_m().PROJECT_ROOT,
check=False,
)
check=False)
if result.returncode != 0:
return None
return resolve_uv() or shutil.which("uv")
@@ -566,8 +518,7 @@ def _npm_lockfile_changed(hermes_root: Path) -> bool:
# Never skip when the web toolchain never landed, or later updates build on a half-installed tree.
web_dir = _m().PROJECT_ROOT / "web"
if (web_dir / "package.json").is_file() and not _web_build_toolchain_ready(
*_web_toolchain_roots(web_dir)
):
*_web_toolchain_roots(web_dir)):
return True
try:
# Key the cache by PROJECT_ROOT so parallel worktrees don't collide.
@@ -600,8 +551,7 @@ def _repair_node_deps_on_current_checkout(
gateway_mode: bool = False,
pre_update_snapshot_id: str | None = None,
completion_message: str = "✓ Already up to date!",
had_desktop_app_before_update: bool = False,
) -> bool:
had_desktop_app_before_update: bool = False) -> bool:
"""Repair Node deps on the ``commit_count == 0`` path.
A current checkout doesn't imply healthy Node deps (a failed npm install says "re-run
@@ -613,8 +563,7 @@ def _repair_node_deps_on_current_checkout(
_check_and_apply_config_migration,
_m,
_rebuild_desktop_after_update,
_update_node_dependencies,
)
_update_node_dependencies)
node_failures = _update_node_dependencies()
if node_failures:
print(f" ⚠ Node.js refresh failed for: {', '.join(node_failures)}")
@@ -626,19 +575,16 @@ def _repair_node_deps_on_current_checkout(
_check_and_apply_config_migration(
assume_yes=assume_yes,
gateway_mode=gateway_mode,
pre_update_snapshot_id=pre_update_snapshot_id,
)
pre_update_snapshot_id=pre_update_snapshot_id)
# A current checkout can still owe a Desktop rebuild (e.g. the Windows hand-off child
# never reaches the commits-pulled rebuild). Self-gates on the build stamp.
if not _rebuild_desktop_after_update(
_m().PROJECT_ROOT / "apps" / "desktop",
had_desktop_app_before_update=had_desktop_app_before_update,
):
had_desktop_app_before_update=had_desktop_app_before_update):
# Retry hint already printed; withhold success rather than claim completion.
print_completion(
"⚠ Update partially complete — the desktop app was not rebuilt "
"and is still on the previous build."
)
"and is still on the previous build.")
return False
return bool(print_completion(completion_message))
@@ -665,8 +611,7 @@ def _update_node_dependencies() -> list[str]:
failed = []
if any(
(_m().PROJECT_ROOT / workspace / "package.json").exists()
for workspace in ("ui-tui", "web")
):
for workspace in ("ui-tui", "web")):
failed.append("ui-tui, web workspaces")
return failed
return []
@@ -704,8 +649,7 @@ def _update_node_dependencies() -> list[str]:
"--workspace", "ui-tui", "--workspace", "web",
# Root devDependencies (shared ESLint config) would otherwise be pruned by the
# scoped install; apps/desktop stays excluded since it is never named above.
"--include-workspace-root",
]
"--include-workspace-root"]
from hermes_constants import with_hermes_node_path
@@ -714,12 +658,7 @@ def _update_node_dependencies() -> list[str]:
# capture_output=False is deliberate: postinstall scripts print download progress and
# capturing makes a long download look hung.
result = _m()._run_npm_install_deterministic(
npm,
_m().PROJECT_ROOT,
extra_args=tuple(install_args),
capture_output=False,
env=nixos_env,
)
npm, _m().PROJECT_ROOT, extra_args=tuple(install_args), capture_output=False, env=nixos_env)
if result.returncode == 0:
_record_npm_lockfile_hash(shared_hermes_root)
print(" ✓ ui-tui, web workspaces installed (desktop skipped)")
@@ -748,9 +687,7 @@ def _venv_core_imports_healthy() -> tuple[bool, str]:
# No venv: normal for a dev checkout (healthy), but on a MANAGED install (bootstrap
# stamp or `.update-incomplete`) the venv IS the install — absence means an interrupted repair.
managed_markers = (
_m().PROJECT_ROOT / ".hermes-bootstrap-complete",
_m()._update_marker_path(),
)
_m().PROJECT_ROOT / ".hermes-bootstrap-complete", _m()._update_marker_path())
if any(m.exists() for m in managed_markers):
return False, f"venv python missing ({venv_python})"
return True, ""
@@ -764,15 +701,11 @@ def _venv_core_imports_healthy() -> tuple[bool, str]:
"for m in mods:\n"
" try: importlib.import_module(m)\n"
" except Exception as e: missing.append(f'{m}: {e}')\n"
"print('\\n'.join(missing))\n"
)
"print('\\n'.join(missing))\n")
try:
result = subprocess.run(
[str(venv_python), "-c", check],
capture_output=True,
text=True, encoding="utf-8", errors="replace",
timeout=60,
cwd=_m().PROJECT_ROOT,
[str(venv_python), "-c", check], capture_output=True, text=True, encoding="utf-8",
errors="replace", timeout=60, cwd=_m().PROJECT_ROOT,
)
except Exception as exc:
logger.debug("venv health probe failed to run: %s", exc)
@@ -797,8 +730,7 @@ def _venv_core_imports_healthy() -> tuple[bool, str]:
# Keys are ``sys.modules`` prefixes; values are ``(display name, PyPI dist)``.
_SELF_LOCKING_NATIVE_MODULES: dict[str, tuple[str, str]] = {
"cryptography.hazmat.bindings._rust": ("cryptography (_rust.pyd)", "cryptography"),
"yaml._yaml": ("PyYAML (_yaml.pyd)", "pyyaml"),
}
"yaml._yaml": ("PyYAML (_yaml.pyd)", "pyyaml")}
def _dependency_sync_would_rewrite(dist_name: str) -> bool | None:
@@ -912,13 +844,11 @@ def _desktop_app_present(desktop_dir: Path) -> bool:
from hermes_cli.update_cmd import _m
return (
_m()._desktop_packaged_executable(desktop_dir) is not None
or _m()._desktop_dist_exists(desktop_dir)
)
or _m()._desktop_dist_exists(desktop_dir))
def _rebuild_desktop_after_update(
desktop_dir: Path, *, had_desktop_app_before_update: bool
) -> bool:
desktop_dir: Path, *, had_desktop_app_before_update: bool) -> bool:
"""Rebuild an installed Desktop app when its source or artifact changed. Returns ``False``
only when a rebuild was attempted and failed (caller withholds ``✓ Update complete!`` and
writes a failing ``.update_exit_code`` in gateway mode); every other outcome is ``True``."""
@@ -929,8 +859,7 @@ def _rebuild_desktop_after_update(
if not (
(desktop_dir / "package.json").exists()
and _m()._resolve_node_runtime_npm()
and has_desktop_app
):
and has_desktop_app):
return True
print("→ Checking if desktop app needs rebuilding...")
@@ -940,8 +869,7 @@ def _rebuild_desktop_after_update(
skip_desktop_build = False
try:
skip_desktop_build = not _m()._desktop_build_needed(
desktop_dir, _m().PROJECT_ROOT, source_mode=False
)
desktop_dir, _m().PROJECT_ROOT, source_mode=False)
except Exception:
skip_desktop_build = False
if skip_desktop_build:
@@ -956,12 +884,10 @@ def _rebuild_desktop_after_update(
build_env = with_hermes_node_path()
build_result = _m()._run_logged_subprocess(
desktop_build_cmd, cwd=_m().PROJECT_ROOT, env=build_env
)
desktop_build_cmd, cwd=_m().PROJECT_ROOT, env=build_env)
if build_result.returncode != 0:
build_result = _m()._run_logged_subprocess(
desktop_build_cmd, cwd=_m().PROJECT_ROOT, env=build_env
)
desktop_build_cmd, cwd=_m().PROJECT_ROOT, env=build_env)
if build_result.returncode != 0:
print(" ⚠ Desktop build failed (run `hermes desktop` to retry)")
tail = "\n".join((build_result.stdout or "").strip().splitlines()[-15:])
@@ -1076,8 +1002,7 @@ def _sync_python_dependencies_after_pull(
*,
active_lazy_features,
active_tool_dependencies,
_windows_gateway_resume,
):
_windows_gateway_resume):
"""Reinstall Python deps for the pulled checkout. Order matters: ownership preflight ->
self-lock deferral -> core marker -> ``.[all]`` -> bytecode sweep -> lazy/tool refresh (own
marker) -> memory-provider deps -> critical-import probe (warn only; stale bytecode self-heals)."""
@@ -1086,8 +1011,7 @@ def _sync_python_dependencies_after_pull(
_sweep_bytecode_after_update,
_validate_critical_modules_import,
_write_lazy_refresh_incomplete_marker,
_write_update_incomplete_marker,
)
_write_update_incomplete_marker)
_refuse_update_if_venv_foreign_owned(_m().PROJECT_ROOT)
# Self-lock deferral: if THIS process holds a native extension the sync must rewrite, defer
# NOW (after the code swap) so only the install is pending for the next launch's marker.
@@ -1128,8 +1052,7 @@ def _sync_python_dependencies_after_pull(
print(" → Termux/Android detected: prebuilding psutil with Linux source path compatibility...")
_install_psutil_android_compat([uv_bin, "pip"], env=uv_env)
_m()._install_python_dependencies_with_optional_fallback(
[uv_bin, "pip"], env=uv_env, group=install_group
)
[uv_bin, "pip"], env=uv_env, group=install_group)
else:
# sys.executable -m pip avoids PEP 668 'externally-managed-environment' errors.
pip_cmd = [sys.executable, "-m", "pip"]
@@ -1168,17 +1091,13 @@ def _sync_python_dependencies_after_pull(
# Clear the lazy marker only when refresh/repair is confirmed healthy.
lazy_ok = _m()._refresh_active_lazy_features(
install_prefix,
env=lazy_env,
features=active_lazy_features,
)
install_prefix, env=lazy_env, features=active_lazy_features)
if lazy_ok:
_m()._clear_lazy_refresh_incomplete_marker()
else:
print(
" ⚠ Lazy-refresh recovery incomplete — run `hermes` again "
"to finish import-based venv repair."
)
"to finish import-based venv repair.")
_m()._restore_active_tool_dependencies(active_tool_dependencies, install_prefix, env=lazy_env)