Merge branch 'simp/r3-24' into simp/integration3
This commit is contained in:
+15
-27
@@ -186,10 +186,8 @@ def _format_extra_metadata_lines(extra: Dict[str, Any]) -> list[str]:
|
||||
# --- Identifier / source resolution ---
|
||||
|
||||
def _resolve_short_name(name: str, sources, console: Console) -> str:
|
||||
"""Short name (e.g. 'pptx') -> full identifier via search; "" when ambiguous/missing.
|
||||
|
||||
One exact match wins; several -> the single official one, else they are listed.
|
||||
"""
|
||||
"""Short name -> full identifier via search; "" when ambiguous/missing (one exact match wins,
|
||||
several -> the single official one, else they are listed)."""
|
||||
from tools.skills_hub import unified_search
|
||||
c = console or _console
|
||||
c.print(f"[dim]Resolving '{name}'...[/]")
|
||||
@@ -263,10 +261,9 @@ def _existing_categories() -> List[str]:
|
||||
"""Sorted category buckets under ``~/.hermes/skills/`` (children without their own SKILL.md)."""
|
||||
from tools.skills_hub import SKILLS_DIR, _category_skill_dirs
|
||||
try:
|
||||
return sorted(
|
||||
name for name in set(_category_skill_dirs(SKILLS_DIR))
|
||||
if not (SKILLS_DIR / name / "SKILL.md").exists())
|
||||
except (FileNotFoundError, OSError):
|
||||
return sorted(name for name in set(_category_skill_dirs(SKILLS_DIR))
|
||||
if not (SKILLS_DIR / name / "SKILL.md").exists())
|
||||
except OSError: # FileNotFoundError is an OSError
|
||||
return []
|
||||
|
||||
|
||||
@@ -646,11 +643,9 @@ def do_install(identifier: str, category: str = "", force: bool = False,
|
||||
console: Optional[Console] = None, skip_confirm: bool = False,
|
||||
invalidate_cache: bool = True, name_override: str = "",
|
||||
source_id: Optional[str] = None) -> None:
|
||||
"""Fetch, quarantine, scan, confirm, and install a skill.
|
||||
|
||||
``source_id`` pins resolution to one adapter; callers that know the provenance (``do_update``)
|
||||
must pass it so a bare identifier cannot resolve to a same-named skill elsewhere.
|
||||
"""
|
||||
"""Fetch, quarantine, scan, confirm, and install a skill. ``source_id`` pins resolution to one
|
||||
adapter; callers that know the provenance (``do_update``) must pass it so a bare identifier
|
||||
cannot resolve to a same-named skill elsewhere."""
|
||||
from tools.skills_hub import (ensure_hub_dirs, quarantine_bundle, install_from_quarantine,
|
||||
HubLockFile)
|
||||
from tools.skills_guard import should_allow_install
|
||||
@@ -1077,8 +1072,8 @@ def do_tap(action: str, repo: str = "", console: Optional[Console] = None) -> No
|
||||
return
|
||||
table = _table(("Repo", {"style": "bold cyan"}), "Path", title="Configured Taps")
|
||||
for t in taps:
|
||||
label = t.get("repo") or t.get("name") or t.get("path", "unknown")
|
||||
table.add_row(label, t.get("path", "skills/"))
|
||||
table.add_row(t.get("repo") or t.get("name") or t.get("path", "unknown"),
|
||||
t.get("path", "skills/"))
|
||||
c.print(table)
|
||||
c.print()
|
||||
elif action in _TAP_OPS:
|
||||
@@ -1229,9 +1224,8 @@ def do_snapshot_export(output_path: str, console: Optional[Console] = None) -> N
|
||||
if output_path == "-":
|
||||
sys.stdout.write(payload)
|
||||
return
|
||||
out = Path(output_path)
|
||||
out.write_text(payload, encoding="utf-8")
|
||||
c.print(f"[bold green]Snapshot exported:[/] {out}")
|
||||
Path(output_path).write_text(payload, encoding="utf-8")
|
||||
c.print(f"[bold green]Snapshot exported:[/] {Path(output_path)}")
|
||||
c.print(f"[dim]{len(installed)} skill(s), {len(tap_list)} tap(s)[/]\n")
|
||||
|
||||
|
||||
@@ -1320,8 +1314,7 @@ _CLI_ACTIONS = {
|
||||
skip_confirm=getattr(a, "yes", False)),
|
||||
"publish": lambda a: do_publish(a.skill_path, target=getattr(a, "to", "github"),
|
||||
repo=getattr(a, "repo", "")),
|
||||
"snapshot": lambda a: _snapshot_cli(a),
|
||||
"tap": lambda a: _tap_cli(a)}
|
||||
"snapshot": _snapshot_cli, "tap": _tap_cli}
|
||||
|
||||
|
||||
def skills_command(args) -> None:
|
||||
@@ -1339,13 +1332,8 @@ def skills_command(args) -> None:
|
||||
def _opt_value(args: List[str], flag: str, default: str, last: bool = False) -> str:
|
||||
"""Value following `flag` (default if absent/trailing); `last` makes a repeated flag's final
|
||||
occurrence win (historical install/publish/browse behaviour), else the first."""
|
||||
found = default
|
||||
for i, a in enumerate(args):
|
||||
if a == flag and i + 1 < len(args):
|
||||
found = args[i + 1]
|
||||
if not last:
|
||||
break
|
||||
return found
|
||||
hits = [args[i + 1] for i, a in enumerate(args) if a == flag and i + 1 < len(args)]
|
||||
return (hits[-1] if last else hits[0]) if hits else default
|
||||
|
||||
|
||||
def _int_or(text: str, default: int) -> int:
|
||||
|
||||
+15
-29
@@ -16,40 +16,26 @@ from hermes_cli.toolset_scope import (
|
||||
_TOOLSET_PLATFORM_RESTRICTIONS, toolset_allowed_for_platform as _toolset_allowed_for_platform)
|
||||
# Re-exports: keep ``hermes_cli.tools_config.X`` callers and test patch targets resolving.
|
||||
from hermes_cli.tools_config_cua import ( # noqa: F401
|
||||
_post_setup_no_window_flags, _cua_driver_cmd, _cua_version_summary, _resolved_cua_driver_cmd,
|
||||
_cua_driver_env, _CUA_DRIVER_CONTRACT_CACHE, _cua_driver_contract_status, _cua_driver_install_ready,
|
||||
_pip_install, _cua_install_target_writable, _cua_driver_version, install_cua_driver,
|
||||
_CUA_INSTALLER_TIMEOUT, _CUA_INSTALLER_DRAIN_GRACE, _CUA_BACKGROUND_UPDATE_TIMEOUT, _CUA_LOCK_STALE_AFTER,
|
||||
_cua_install_home, _cua_install_lock_dir, _cua_windows_install_lock_file,
|
||||
_post_setup_no_window_flags, _cua_driver_cmd, _cua_version_summary, _resolved_cua_driver_cmd, _cua_driver_env,
|
||||
_cua_driver_contract_status, _cua_driver_install_ready, _pip_install, _cua_install_target_writable,
|
||||
install_cua_driver, _CUA_INSTALLER_TIMEOUT, _CUA_INSTALLER_DRAIN_GRACE, _CUA_LOCK_STALE_AFTER,
|
||||
_clear_stale_windows_cua_install_lock, _clear_stale_cua_install_lock, _cua_install_lock_held,
|
||||
_cua_release_endpoint_reachable, _ps_single_quote, _cua_driver_autostart_registered_windows,
|
||||
_repair_cua_driver_autostart_windows, _remove_quietly, _print_cua_platform_notes,
|
||||
_run_cua_driver_installer)
|
||||
_cua_release_endpoint_reachable, _repair_cua_driver_autostart_windows, _run_cua_driver_installer)
|
||||
from hermes_cli.tools_config_post_setup import ( # noqa: F401
|
||||
_ensure_browser_use_cli, _post_setup_lightpanda, _post_setup_agent_browser, _post_setup_camofox,
|
||||
_KITTENTTS_WHEEL_URL, _PIP_POST_SETUP_HOOKS, _post_setup_pip, _post_setup_spotify, _post_setup_langfuse,
|
||||
_post_setup_xai_grok, _POST_SETUP_HOOKS, _run_post_setup, valid_post_setup_keys, run_post_setup_command,
|
||||
_POST_SETUP_INSTALLED, _post_setup_already_installed, _module_installed,
|
||||
_RESTORABLE_PYTHON_TOOL_DEPENDENCIES, active_restorable_python_tool_dependencies,
|
||||
restorable_python_tool_dependency, _agent_browser_installed, _camofox_installed, _lightpanda_installed,
|
||||
_cloud_agent_browser_installed, _POST_SETUP_READY)
|
||||
_ensure_browser_use_cli, _run_post_setup, valid_post_setup_keys, run_post_setup_command, _POST_SETUP_INSTALLED,
|
||||
_post_setup_already_installed, _module_installed, active_restorable_python_tool_dependencies,
|
||||
restorable_python_tool_dependency, _POST_SETUP_READY)
|
||||
from hermes_cli.tools_config_providers import ( # noqa: F401
|
||||
_plugin_provider_rows, _plugin_image_gen_providers, _plugin_video_gen_providers,
|
||||
_plugin_web_search_providers, _plugin_browser_providers, _plugin_tts_providers, web_provider_capabilities,
|
||||
_PLUGIN_ROW_BUILDERS, _visible_providers, provider_readiness_status, _toolset_needs_configuration_prompt,
|
||||
_any_plugin_provider_available, _configure_tool_category, _web_tier_matches, _is_provider_active,
|
||||
_detect_active_provider_index, _fal_model_catalog, IMAGEGEN_BACKENDS, _plugin_model_catalog,
|
||||
_plugin_image_gen_catalog, _plugin_video_gen_catalog, _pick_model_from_catalog, _configure_imagegen_model,
|
||||
_configure_imagegen_model_for_plugin, _configure_videogen_model_for_plugin,
|
||||
_configure_xai_imagine_storage, _select_plugin_gen_provider, _select_plugin_image_gen_provider,
|
||||
_select_plugin_video_gen_provider, STT_MODEL_CATALOG, _STT_MODEL_CONFIG_KEY, _configure_stt_model,
|
||||
_PROVIDER_MARKER_SECTIONS, _write_provider_config, apply_provider_selection, _nous_provider_gate,
|
||||
_finish_provider_selection, _print_provider_selection, _configure_provider, _reconfigure_provider,
|
||||
_plugin_image_gen_providers, _plugin_video_gen_providers, _plugin_web_search_providers, _plugin_browser_providers,
|
||||
_plugin_tts_providers, web_provider_capabilities, _visible_providers, provider_readiness_status,
|
||||
_toolset_needs_configuration_prompt, _configure_tool_category, _web_tier_matches, _is_provider_active,
|
||||
_detect_active_provider_index, IMAGEGEN_BACKENDS, _plugin_image_gen_catalog, _plugin_video_gen_catalog,
|
||||
_configure_imagegen_model, _configure_imagegen_model_for_plugin, _configure_videogen_model_for_plugin,
|
||||
_select_plugin_image_gen_provider, _select_plugin_video_gen_provider, STT_MODEL_CATALOG, _configure_stt_model,
|
||||
_write_provider_config, apply_provider_selection, _configure_provider, _reconfigure_provider,
|
||||
_configure_vision_backend, _configure_vision_provider_model, _configure_simple_requirements)
|
||||
from hermes_cli.tools_config_mcp import ( # noqa: F401
|
||||
_mcp_match_filter, _mcp_preselected, _apply_mcp_checklist, _configure_mcp_tools_interactive,
|
||||
_apply_toolset_change, _apply_mcp_change, _print_tools_list, _known_tool_platforms,
|
||||
tools_disable_enable_command)
|
||||
_configure_mcp_tools_interactive, _apply_toolset_change, _apply_mcp_change, tools_disable_enable_command)
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
+291
-345
@@ -1,12 +1,17 @@
|
||||
"""cua-driver installer, lock hygiene and pip-install helper for `hermes tools` / `hermes computer-use install`."""
|
||||
"""cua-driver installer, lock hygiene and pip-install helper for `hermes tools` /
|
||||
`hermes computer-use install`."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import contextlib
|
||||
import logging
|
||||
import os
|
||||
import platform
|
||||
import re
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
from pathlib import Path
|
||||
from typing import List, Optional
|
||||
|
||||
@@ -15,55 +20,64 @@ from hermes_cli.cli_output import (
|
||||
|
||||
logger = logging.getLogger("hermes_cli.tools_config")
|
||||
|
||||
# Ceiling for one upstream-installer run: must exceed the installer's own stale-lock recovery window
|
||||
# (_install-rust.sh force-releases a dead holder's lock only after LOCK_STALE_AFTER_SECONDS=600; a shorter
|
||||
# timeout kills every run before that fires — a permanent wedge). 660s = 600s + 60s headroom.
|
||||
# One upstream-installer run must outlive the installer's own stale-lock recovery (_install-rust.sh
|
||||
# force-releases a dead holder's lock only after LOCK_STALE_AFTER_SECONDS=600; a shorter timeout
|
||||
# kills every run before that fires — a permanent wedge). 660s = 600s + 60s headroom.
|
||||
_CUA_INSTALLER_TIMEOUT = 660
|
||||
|
||||
# Grace for draining the installer's pipes after a timeout kill. The kill is best-effort (_reap_after_timeout)
|
||||
# so the drain must be bounded: a surviving descendant holding the inherited stdout handle would otherwise
|
||||
# make the read wait on an EOF that never comes. A successful kill closes the pipe at once, so this is free.
|
||||
# Bounded pipe drain after a timeout kill: the kill is best-effort (_reap_after_timeout), and a
|
||||
# surviving descendant holding the inherited stdout would otherwise block the read on an EOF that
|
||||
# never comes. A successful kill closes the pipe at once, so this costs nothing.
|
||||
_CUA_INSTALLER_DRAIN_GRACE = 15
|
||||
|
||||
# Quiet unattended refreshes from ``hermes update``: bounded even when upstream waits on Read-Host or a
|
||||
# consent prompt; explicit ``computer-use install --upgrade`` keeps the full ceiling. Safe because the
|
||||
# lock/network preflights make a legitimate long wait impossible here.
|
||||
# Quiet ``hermes update`` refreshes stay bounded even when upstream waits on Read-Host / a consent
|
||||
# prompt (explicit ``install --upgrade`` keeps the full ceiling); safe because the lock/network
|
||||
# preflights make a legitimate long wait impossible here.
|
||||
_CUA_BACKGROUND_UPDATE_TIMEOUT = 120
|
||||
|
||||
# Upstream installer's stale-lock threshold (LOCK_STALE_AFTER_SECONDS in _install-rust.sh), so the
|
||||
# pre-clear never yanks a lock a live-but-slow install still holds.
|
||||
# Upstream's LOCK_STALE_AFTER_SECONDS: the pre-clear never yanks a lock a live install still holds.
|
||||
_CUA_LOCK_STALE_AFTER = 600
|
||||
|
||||
_CUA_INSTALL_PS1_URL = "https://raw.githubusercontent.com/trycua/cua/main/libs/cua-driver/scripts/install.ps1"
|
||||
_CUA_INSTALL_SH_URL = "https://raw.githubusercontent.com/trycua/cua/main/libs/cua-driver/scripts/install.sh"
|
||||
_CUA_INSTALL_PS1_URL = (
|
||||
"https://raw.githubusercontent.com/trycua/cua/main/libs/cua-driver/scripts/install.ps1")
|
||||
_CUA_INSTALL_SH_URL = (
|
||||
"https://raw.githubusercontent.com/trycua/cua/main/libs/cua-driver/scripts/install.sh")
|
||||
_CUA_MANUAL_README = "https://github.com/trycua/cua/blob/main/libs/cua-driver/README.md"
|
||||
_UPGRADE_CMD = "hermes computer-use install --upgrade"
|
||||
|
||||
|
||||
def _run_text(cmd: list, *, timeout, capture_output: bool = True, **kwargs) -> subprocess.CompletedProcess:
|
||||
def _run_text(cmd: list, *, timeout, capture_output: bool = True,
|
||||
**kwargs) -> subprocess.CompletedProcess:
|
||||
"""``subprocess.run`` with the utf-8/replace text decoding every helper here uses."""
|
||||
return subprocess.run(
|
||||
cmd, capture_output=capture_output, text=True, encoding="utf-8", errors="replace", timeout=timeout, **kwargs,
|
||||
)
|
||||
return subprocess.run(cmd, capture_output=capture_output, text=True, encoding="utf-8",
|
||||
errors="replace", timeout=timeout, **kwargs)
|
||||
|
||||
|
||||
def _fail(message: str, *hints: str, warn: bool = True) -> bool:
|
||||
"""Print ``message`` (warning, or info when ``warn=False``) plus info hints; returns False."""
|
||||
(_print_warning if warn else _print_info)(message)
|
||||
for hint in hints:
|
||||
_print_info(hint)
|
||||
return False
|
||||
|
||||
|
||||
def _print_output_tail(result: subprocess.CompletedProcess, printer=None) -> None:
|
||||
"""Echo the last three lines of a failed command's stderr (or stdout) as indented info.
|
||||
``printer`` lets another module route through its own (test-patchable) ``_print_info``."""
|
||||
for line in (result.stderr or result.stdout or "").strip().splitlines()[-3:]:
|
||||
(printer or _print_info)(f" {line[:200]}")
|
||||
|
||||
|
||||
def _post_setup_no_window_flags(*, streams_to_console: bool = False) -> int:
|
||||
"""Win32 creationflags that stop post-setup children flashing a console.
|
||||
CREATE_NO_WINDOW hides console grandchildren (npm, pip, powershell) while keeping stdio inheritable
|
||||
(unlike DETACHED_PROCESS). Returns 0 on POSIX. ``streams_to_console`` children are only hidden when
|
||||
our own stdout is not a console, so live installer output is never swallowed."""
|
||||
"""Win32 creationflags that stop post-setup children flashing a console (0 on POSIX).
|
||||
CREATE_NO_WINDOW hides console grandchildren (npm, pip, powershell) while keeping stdio
|
||||
inheritable (unlike DETACHED_PROCESS). ``streams_to_console`` children are only hidden when our
|
||||
own stdout is not a console, so live installer output is never swallowed."""
|
||||
from hermes_cli._subprocess_compat import windows_hide_flags
|
||||
|
||||
flags = windows_hide_flags()
|
||||
if not flags:
|
||||
return 0
|
||||
if streams_to_console:
|
||||
try:
|
||||
if sys.stdout is not None and sys.stdout.isatty():
|
||||
return 0
|
||||
except Exception:
|
||||
pass
|
||||
return flags
|
||||
try:
|
||||
if flags and streams_to_console and sys.stdout is not None and sys.stdout.isatty():
|
||||
return 0
|
||||
except Exception:
|
||||
pass
|
||||
return flags or 0
|
||||
|
||||
|
||||
def _cua_driver_cmd() -> str:
|
||||
@@ -72,25 +86,21 @@ def _cua_driver_cmd() -> str:
|
||||
|
||||
|
||||
def _cua_version_summary(raw: str, *, limit: int = 120) -> str:
|
||||
"""First non-empty line of ``--version`` output, bounded (an override may print a multi-line banner)."""
|
||||
"""First non-empty line of ``--version`` output, bounded (an override may print a banner)."""
|
||||
return next((line.strip()[:limit] for line in (raw or "").splitlines() if line.strip()), "")
|
||||
|
||||
|
||||
def _resolved_cua_driver_cmd() -> Optional[str]:
|
||||
"""Resolve cua-driver exactly as the runtime and Desktop status do."""
|
||||
from tools.computer_use.cua_backend import resolve_cua_driver_cmd
|
||||
|
||||
return resolve_cua_driver_cmd()
|
||||
|
||||
|
||||
def _cua_driver_env() -> dict:
|
||||
"""cua-driver child env with the Hermes telemetry policy applied (``cua_backend.cua_driver_child_env``).
|
||||
|
||||
Falls back to the current environment if the helper can't be imported, so install/status never break.
|
||||
"""
|
||||
"""cua-driver child env with the Hermes telemetry policy applied; falls back to the current
|
||||
environment if the helper can't be imported, so install/status never break."""
|
||||
try:
|
||||
from tools.computer_use.cua_backend import cua_driver_child_env
|
||||
|
||||
return cua_driver_child_env()
|
||||
except Exception:
|
||||
return dict(os.environ)
|
||||
@@ -100,12 +110,9 @@ _CUA_DRIVER_CONTRACT_CACHE: dict = {}
|
||||
|
||||
|
||||
def _cua_driver_contract_status(binary: Optional[str] = None) -> dict:
|
||||
"""Inspect whether an installed driver supports Hermes' runtime contract (30s cache keyed on the binary's
|
||||
path/mtime/size fingerprint)."""
|
||||
import time
|
||||
|
||||
"""Inspect whether an installed driver supports Hermes' runtime contract (30s cache keyed on the
|
||||
binary's path/mtime/size fingerprint)."""
|
||||
from tools.computer_use.cua_backend import cua_driver_runtime_contract_status
|
||||
|
||||
resolved = binary or _resolved_cua_driver_cmd()
|
||||
if not resolved:
|
||||
return cua_driver_runtime_contract_status(None)
|
||||
@@ -114,12 +121,10 @@ def _cua_driver_contract_status(binary: Optional[str] = None) -> dict:
|
||||
fingerprint = (resolved, stat.st_mtime_ns, stat.st_size)
|
||||
except OSError:
|
||||
return cua_driver_runtime_contract_status(resolved)
|
||||
|
||||
now = time.monotonic()
|
||||
cache = _CUA_DRIVER_CONTRACT_CACHE
|
||||
if cache.get("fingerprint") == fingerprint and now - cache.get("checked_at", 0.0) < 30.0:
|
||||
return dict(cache["state"])
|
||||
|
||||
state = cua_driver_runtime_contract_status(resolved)
|
||||
cache.update(fingerprint=fingerprint, checked_at=now, state=dict(state))
|
||||
return state
|
||||
@@ -127,60 +132,53 @@ def _cua_driver_contract_status(binary: Optional[str] = None) -> dict:
|
||||
|
||||
def _cua_driver_install_ready() -> bool:
|
||||
"""Return whether an existing driver needs no install-time repair."""
|
||||
if not _cua_driver_contract_status().get("ready"):
|
||||
return False
|
||||
return sys.platform != "win32" or _cua_driver_autostart_registered_windows()
|
||||
return bool(_cua_driver_contract_status().get("ready")) and (
|
||||
sys.platform != "win32" or _cua_driver_autostart_registered_windows())
|
||||
|
||||
|
||||
def _pip_install(args: List[str], *, timeout: int = 300, capture_output: bool = True):
|
||||
"""Install Python packages from a post-setup hook.
|
||||
Order: ``uv pip install`` (fast, needs no pip in the venv), then ``python -m pip install``, then
|
||||
``python -m ensurepip --upgrade`` and retry pip. The last tier exists because the Windows installer
|
||||
creates the venv via ``uv venv``, which does NOT seed pip, so bare ``-m pip`` failed on fresh
|
||||
installs."""
|
||||
"""Install Python packages: ``uv pip install`` (needs no pip in the venv), then ``python -m
|
||||
pip``, then ``ensurepip --upgrade`` + retry — the Windows installer creates the venv via
|
||||
``uv venv``, which does NOT seed pip, so bare ``-m pip`` failed on fresh installs."""
|
||||
venv_root = Path(sys.executable).parent.parent
|
||||
uv_env = {**os.environ, "VIRTUAL_ENV": str(venv_root)}
|
||||
install_flags = _post_setup_no_window_flags(streams_to_console=not capture_output)
|
||||
|
||||
# Managed uv first: $HERMES_HOME/bin is never on PATH, so a bare which() misses the uv Hermes installed;
|
||||
# ensure_uv() (not a pure lookup) because installing uv is in scope during setup.
|
||||
# Managed uv first: $HERMES_HOME/bin is never on PATH, so a bare which() misses the uv Hermes
|
||||
# installed; ensure_uv() (not a pure lookup) because installing uv is in scope during setup.
|
||||
from hermes_cli.managed_uv import ensure_uv
|
||||
|
||||
uv_bin = ensure_uv()
|
||||
if uv_bin:
|
||||
try:
|
||||
result = _run_text([uv_bin, "pip", "install", *args], capture_output=capture_output, timeout=timeout,
|
||||
env=uv_env, creationflags=install_flags)
|
||||
if result.returncode == 0:
|
||||
return result
|
||||
# Fall through to pip — uv may have failed for a reason pip can handle.
|
||||
except (subprocess.TimeoutExpired, FileNotFoundError):
|
||||
pass
|
||||
|
||||
try: # a failed uv run falls through to pip — it may have failed for a reason pip can handle
|
||||
result = uv_bin and _run_text([uv_bin, "pip", "install", *args], timeout=timeout,
|
||||
capture_output=capture_output, creationflags=install_flags,
|
||||
env={**os.environ, "VIRTUAL_ENV": str(venv_root)})
|
||||
if result and result.returncode == 0:
|
||||
return result
|
||||
except (subprocess.TimeoutExpired, FileNotFoundError):
|
||||
pass
|
||||
pip_cmd = [sys.executable, "-m", "pip"]
|
||||
try:
|
||||
# Probe for pip; bootstrap via ensurepip if missing (uv venv lacks it).
|
||||
probe = _run_text(pip_cmd + ["--version"], timeout=15, creationflags=_post_setup_no_window_flags())
|
||||
probe = _run_text(pip_cmd + ["--version"], timeout=15,
|
||||
creationflags=_post_setup_no_window_flags())
|
||||
if probe.returncode != 0:
|
||||
raise FileNotFoundError("pip not in venv")
|
||||
except (subprocess.TimeoutExpired, FileNotFoundError):
|
||||
try:
|
||||
_run_text([sys.executable, "-m", "ensurepip", "--upgrade", "--default-pip"], timeout=120, check=True,
|
||||
creationflags=_post_setup_no_window_flags())
|
||||
_run_text([sys.executable, "-m", "ensurepip", "--upgrade", "--default-pip"],
|
||||
timeout=120, check=True, creationflags=_post_setup_no_window_flags())
|
||||
except (subprocess.CalledProcessError, subprocess.TimeoutExpired) as e:
|
||||
# Synthesize a result so callers see a clean failure path.
|
||||
return subprocess.CompletedProcess(
|
||||
pip_cmd, returncode=1, stdout="", stderr=f"pip not available and ensurepip failed: {e}",
|
||||
)
|
||||
|
||||
pip_cmd, returncode=1, stdout="",
|
||||
stderr=f"pip not available and ensurepip failed: {e}")
|
||||
return _run_text(pip_cmd + ["install", *args], capture_output=capture_output, timeout=timeout,
|
||||
creationflags=install_flags)
|
||||
|
||||
|
||||
# No pre-install release/asset probe: cua-driver-rs releases are all prereleases, which GitHub's
|
||||
# `/releases/latest` skips (zero binary assets → every non-arm64 host skipped the install), and
|
||||
# re-implementing upstream's tag resolution here would drift. Fresh installs run install.sh directly (it
|
||||
# errors clean on a missing-arch asset); upgrades ask the binary via `cua_driver_update_check()`.
|
||||
# re-implementing upstream's tag resolution here would drift. Fresh installs run install.sh directly
|
||||
# (it errors clean on a missing-arch asset); upgrades ask the binary via cua_driver_update_check().
|
||||
|
||||
|
||||
def _cua_install_target_writable() -> bool:
|
||||
@@ -204,10 +202,11 @@ def _cua_driver_version(binary: str) -> Optional[str]:
|
||||
|
||||
def _confirmed_update_check(driver_cmd: str, require_confirmed_update: bool) -> tuple:
|
||||
"""Ask the installed driver whether a newer release exists; returns ``(proceed, pin_version)``.
|
||||
``proceed=False`` means stop with success (already latest, or indeterminate under
|
||||
``require_confirmed_update``). An old driver (no check-update verb) or offline check yields None:
|
||||
`hermes update` then keeps the installed version — an indeterminate check must never cost a
|
||||
multi-minute silent reinstall on every update — while explicit `install --upgrade` falls through."""
|
||||
``proceed=False`` = stop with success (already latest, or indeterminate under
|
||||
``require_confirmed_update``). An old driver (no check-update verb) or offline check yields
|
||||
None: `hermes update` then keeps the installed version — an indeterminate check must never
|
||||
cost a multi-minute silent reinstall on every update — while explicit `install --upgrade`
|
||||
falls through."""
|
||||
try:
|
||||
from tools.computer_use.cua_backend import cua_driver_update_check
|
||||
_state = cua_driver_update_check()
|
||||
@@ -215,77 +214,80 @@ def _confirmed_update_check(driver_cmd: str, require_confirmed_update: bool) ->
|
||||
_state = None
|
||||
if _state is None:
|
||||
if require_confirmed_update:
|
||||
_print_info(
|
||||
f" Could not confirm a newer {driver_cmd} release "
|
||||
"(offline, rate-limited, or driver too old to check); "
|
||||
"keeping the installed version.")
|
||||
_print_info(f" Force a refresh with: {_UPGRADE_CMD}")
|
||||
return False, None
|
||||
return True, None
|
||||
_fail(f" Could not confirm a newer {driver_cmd} release (offline, rate-limited, or "
|
||||
"driver too old to check); keeping the installed version.",
|
||||
f" Force a refresh with: {_UPGRADE_CMD}", warn=False)
|
||||
return not require_confirmed_update, None
|
||||
if not _state.get("update_available"):
|
||||
_print_success(
|
||||
f" {driver_cmd} is already on the latest release "
|
||||
f"({_state.get('current_version') or 'unknown'}).")
|
||||
_print_success(f" {driver_cmd} is already on the latest release "
|
||||
f"({_state.get('current_version') or 'unknown'}).")
|
||||
return False, None
|
||||
# Windows routine upgrades run unattended-safe (stdin closed, version pinned, ceiling
|
||||
# _CUA_BACKGROUND_UPDATE_TIMEOUT, preflights skip in seconds); only contract repairs and fresh
|
||||
# installs stay interactive-only, where upstream needs a human (autostart elevation, SmartScreen).
|
||||
# Pin to the release check-update confirmed: `latest_version` comes from the GitHub Releases API so
|
||||
# its assets exist, unlike the installer's baked version on `main`, which is bumped before assets
|
||||
# are published and 404s unpinned. Malformed values are ignored → unpinned fallback.
|
||||
import re as _re
|
||||
|
||||
# installs stay interactive-only, where upstream needs a human (autostart elevation/SmartScreen).
|
||||
# Pin to the release check-update confirmed: `latest_version` comes from the GitHub Releases API
|
||||
# so its assets exist, unlike the installer's baked version on `main` (bumped before assets are
|
||||
# published → 404s unpinned). Malformed values are ignored → unpinned fallback.
|
||||
_latest = str(_state.get("latest_version") or "").strip().lstrip("vV")
|
||||
return True, (_latest if _re.fullmatch(r"\d+(\.\d+)*", _latest) else None)
|
||||
return True, (_latest if re.fullmatch(r"\d+(\.\d+)*", _latest) else None)
|
||||
|
||||
|
||||
def install_cua_driver(
|
||||
upgrade: bool = False, require_confirmed_update: bool = False, show_installer_progress: bool = True,
|
||||
) -> bool:
|
||||
def _report_repair_or_upgrade(ok: bool, *, repair_existing: bool, binary, before: str,
|
||||
driver_cmd: str) -> bool:
|
||||
"""Post-installer verdict: a repair must leave a usable contract; upgrades show before/after."""
|
||||
if ok and repair_existing:
|
||||
repaired = _cua_driver_contract_status()
|
||||
if not repaired.get("ready"):
|
||||
return _fail(" cua-driver was reinstalled, but its runtime contract is still "
|
||||
f"unusable: {repaired.get('reason') or 'unknown error'}.",
|
||||
" Run: hermes computer-use doctor")
|
||||
if ok and before:
|
||||
after = _cua_driver_version(binary)
|
||||
if after and after != before:
|
||||
_print_success(f" {driver_cmd} upgraded: {before} → {after}")
|
||||
elif after:
|
||||
_print_info(f" {driver_cmd} up to date: {after}")
|
||||
return ok
|
||||
|
||||
|
||||
def install_cua_driver(upgrade: bool = False, require_confirmed_update: bool = False,
|
||||
show_installer_progress: bool = True) -> bool:
|
||||
"""Install or refresh the cua-driver binary used by Computer Use.
|
||||
The upstream installer always pulls the latest release tag, so re-running it is the canonical way to
|
||||
upgrade. ``upgrade=False`` (toolset enable flow) keeps a compatible installation, repairs an
|
||||
Re-running the upstream installer (always the latest release tag) is the canonical upgrade.
|
||||
``upgrade=False`` (toolset enable flow) keeps a compatible installation, repairs an
|
||||
old/incomplete one and installs when missing; ``upgrade=True`` always refreshes."""
|
||||
import platform as _plat
|
||||
|
||||
system = _plat.system()
|
||||
system = platform.system()
|
||||
if system not in ("Darwin", "Windows", "Linux"):
|
||||
if not upgrade: # silent under `hermes update`, which calls this for every user
|
||||
_print_warning(" Computer Use (cua-driver) is unsupported on this platform; skipping.")
|
||||
_print_warning(
|
||||
" Computer Use (cua-driver) is unsupported on this platform; skipping.")
|
||||
return False
|
||||
|
||||
is_windows = system == "Windows"
|
||||
is_linux = system == "Linux"
|
||||
is_windows, is_linux = system == "Windows", system == "Linux"
|
||||
# install.ps1 is fetched via PowerShell's `irm`; macOS/Linux use curl | bash.
|
||||
fetch_tool = "powershell" if is_windows else "curl"
|
||||
|
||||
driver_cmd = _cua_driver_cmd()
|
||||
binary = _resolved_cua_driver_cmd()
|
||||
|
||||
driver_cmd, binary = _cua_driver_cmd(), _resolved_cua_driver_cmd()
|
||||
# An explicit override is authoritative even when broken: installing the standard driver
|
||||
# cannot repair the configured path and would mutate an unrelated installation.
|
||||
override = os.environ.get("HERMES_CUA_DRIVER_CMD", "").strip()
|
||||
if override and not binary:
|
||||
_print_warning(f" HERMES_CUA_DRIVER_CMD does not resolve to an executable: {override}")
|
||||
_print_info(" Fix or unset the override before running computer-use install.")
|
||||
return False
|
||||
return _fail(f" HERMES_CUA_DRIVER_CMD does not resolve to an executable: {override}",
|
||||
" Fix or unset the override before running computer-use install.")
|
||||
|
||||
# Not installed → fresh install path (only when caller asked for it).
|
||||
if not binary and not upgrade:
|
||||
if not _cua_install_target_writable():
|
||||
_print_info(" /Applications is not writable; skipping cua-driver install.")
|
||||
_print_info(" Run from an admin account or install cua-driver manually.")
|
||||
return False
|
||||
return _fail(" /Applications is not writable; skipping cua-driver install.",
|
||||
" Run from an admin account or install cua-driver manually.",
|
||||
warn=False)
|
||||
if not shutil.which(fetch_tool):
|
||||
_print_warning(f" {fetch_tool} not found — install manually:")
|
||||
_print_info(f" {_CUA_MANUAL_README}")
|
||||
return False
|
||||
return _fail(f" {fetch_tool} not found — install manually:",
|
||||
f" {_CUA_MANUAL_README}")
|
||||
return _run_cua_driver_installer(label="Installing")
|
||||
|
||||
# A driver failing Hermes' runtime contract (version floor, missing manifest verbs) is repaired
|
||||
# regardless of mode. Hermes' minimum requirement IS the confirmation an upgrade is needed, so this
|
||||
# path must not defer to the driver's `check-update` verb — a cached/indeterminate "no update"
|
||||
# answer would pin users on an unusable driver forever.
|
||||
# regardless of mode. Hermes' minimum requirement IS the confirmation an upgrade is needed, so
|
||||
# this path must not defer to the driver's `check-update` verb — a cached/indeterminate "no
|
||||
# update" answer would pin users on an unusable driver forever.
|
||||
contract = _cua_driver_contract_status(binary) if binary else None
|
||||
repair_existing = bool(binary and contract and not contract.get("ready"))
|
||||
|
||||
@@ -295,22 +297,21 @@ def install_cua_driver(
|
||||
suffix = "" if version is None else f": {version or 'unknown version'}"
|
||||
_print_success(f" {driver_cmd} already installed{suffix}.")
|
||||
if is_windows and not _repair_cua_driver_autostart_windows(binary, verbose=False):
|
||||
_print_warning(" cua-driver is compatible, but Windows autostart repair failed.")
|
||||
return False
|
||||
return _fail(" cua-driver is compatible, but Windows autostart repair failed.")
|
||||
_print_cua_platform_notes(is_windows, is_linux, fresh_install=False)
|
||||
return True
|
||||
|
||||
if repair_existing:
|
||||
version = contract.get("version") or "unknown version"
|
||||
reason = contract.get("reason") or "required runtime features are missing"
|
||||
_print_warning(f" Found cua-driver {version}, but Hermes cannot use its current runtime contract: {reason}.")
|
||||
_print_warning(f" Found cua-driver {contract.get('version') or 'unknown version'}, but "
|
||||
"Hermes cannot use its current runtime contract: "
|
||||
f"{contract.get('reason') or 'required runtime features are missing'}.")
|
||||
if override:
|
||||
_print_info(f" Update the binary selected by HERMES_CUA_DRIVER_CMD, or unset the override and run: {_UPGRADE_CMD}")
|
||||
return False
|
||||
return _fail(" Update the binary selected by HERMES_CUA_DRIVER_CMD, or unset the "
|
||||
f"override and run: {_UPGRADE_CMD}", warn=False)
|
||||
if is_windows and require_confirmed_update:
|
||||
_print_info(" Automatic Windows updates cannot safely run cua-driver's interactive repair installer.")
|
||||
_print_info(f" Repair it from an interactive terminal with: {_UPGRADE_CMD}")
|
||||
return False
|
||||
return _fail(" Automatic Windows updates cannot safely run cua-driver's interactive "
|
||||
"repair installer.",
|
||||
f" Repair it from an interactive terminal with: {_UPGRADE_CMD}",
|
||||
warn=False)
|
||||
_print_info(" Repairing it with the current upstream installer.")
|
||||
|
||||
# upgrade=True path — refresh to the latest upstream release.
|
||||
@@ -318,47 +319,29 @@ def install_cua_driver(
|
||||
_print_info(" /Applications is not writable; skipping cua-driver refresh.")
|
||||
_print_info(f" Run `{_UPGRADE_CMD}` from an admin account to update it.")
|
||||
return bool(binary)
|
||||
|
||||
if not shutil.which(fetch_tool):
|
||||
_print_warning(f" {fetch_tool} not found — cannot refresh cua-driver.")
|
||||
return bool(binary)
|
||||
|
||||
confirmed_version = None
|
||||
if binary and not repair_existing:
|
||||
proceed, confirmed_version = _confirmed_update_check(driver_cmd, require_confirmed_update)
|
||||
if not proceed:
|
||||
return True
|
||||
|
||||
if is_windows and require_confirmed_update and not binary:
|
||||
# Missing binary (enabled but never installed, or wiped by a failed install): an automatic Windows
|
||||
# update must never launch install.ps1, which can demand console/UAC consent the hidden updater
|
||||
# cannot provide.
|
||||
_print_info(" cua-driver is not installed; automatic Windows updates cannot safely run its interactive installer.")
|
||||
_print_info(f" Install it from an interactive terminal with: {_UPGRADE_CMD}")
|
||||
return False
|
||||
|
||||
# Best-effort before/after version display.
|
||||
before = (_cua_driver_version(binary) or "") if binary else ""
|
||||
|
||||
# Missing binary (enabled but never installed, or wiped by a failed install): an automatic
|
||||
# Windows update must never launch install.ps1, which can demand console/UAC consent the
|
||||
# hidden updater cannot provide.
|
||||
return _fail(" cua-driver is not installed; automatic Windows updates cannot safely run "
|
||||
"its interactive installer.",
|
||||
f" Install it from an interactive terminal with: {_UPGRADE_CMD}",
|
||||
warn=False)
|
||||
before = (_cua_driver_version(binary) or "") if binary else "" # best-effort before/after
|
||||
ok = _run_cua_driver_installer(
|
||||
label="Repairing" if repair_existing else "Refreshing", verbose=False, pin_version=confirmed_version,
|
||||
show_progress=show_installer_progress,
|
||||
label="Repairing" if repair_existing else "Refreshing", verbose=False,
|
||||
pin_version=confirmed_version, show_progress=show_installer_progress,
|
||||
installer_timeout=_CUA_BACKGROUND_UPDATE_TIMEOUT if require_confirmed_update else None)
|
||||
if ok and repair_existing:
|
||||
repaired = _cua_driver_contract_status()
|
||||
if not repaired.get("ready"):
|
||||
_print_warning(
|
||||
" cua-driver was reinstalled, but its runtime contract is still "
|
||||
f"unusable: {repaired.get('reason') or 'unknown error'}.")
|
||||
_print_info(" Run: hermes computer-use doctor")
|
||||
return False
|
||||
if ok and before:
|
||||
after = _cua_driver_version(binary)
|
||||
if after and after != before:
|
||||
_print_success(f" {driver_cmd} upgraded: {before} → {after}")
|
||||
elif after:
|
||||
_print_info(f" {driver_cmd} up to date: {after}")
|
||||
return ok
|
||||
return _report_repair_or_upgrade(ok, repair_existing=repair_existing, binary=binary,
|
||||
before=before, driver_cmd=driver_cmd)
|
||||
|
||||
|
||||
def _cua_install_home() -> "Path":
|
||||
@@ -378,48 +361,39 @@ def _cua_windows_install_lock_file() -> "Path":
|
||||
|
||||
def _clear_stale_windows_cua_install_lock() -> None:
|
||||
"""Delete install.ps1's lock file only when no process still holds it.
|
||||
install.ps1 locks with ``FileShare::None``; mirror it with a zero-share ``CreateFileW`` probe and
|
||||
``FILE_FLAG_DELETE_ON_CLOSE`` so an unlocked leftover is removed atomically, with no window in which
|
||||
a new installer could acquire the file between probe and delete."""
|
||||
install.ps1 locks with ``FileShare::None``; mirror it with a zero-share ``CreateFileW`` probe
|
||||
and ``FILE_FLAG_DELETE_ON_CLOSE`` so an unlocked leftover is removed atomically, with no window
|
||||
in which a new installer could acquire the file between probe and delete."""
|
||||
lock_file = _cua_windows_install_lock_file()
|
||||
try:
|
||||
if not lock_file.is_file():
|
||||
return
|
||||
|
||||
import ctypes as _ctypes
|
||||
from ctypes import wintypes as _wintypes
|
||||
|
||||
# Win32 constants used by install.ps1's FileShare::None equivalent.
|
||||
delete_access, generic_read, generic_write = 0x00010000, 0x80000000, 0x40000000
|
||||
open_existing, file_attribute_normal, file_flag_delete_on_close = 3, 0x00000080, 0x04000000
|
||||
|
||||
kernel32 = _ctypes.WinDLL("kernel32", use_last_error=True)
|
||||
create_file = kernel32.CreateFileW
|
||||
create_file.argtypes = [
|
||||
_wintypes.LPCWSTR, _wintypes.DWORD, _wintypes.DWORD, _wintypes.LPVOID,
|
||||
_wintypes.DWORD, _wintypes.DWORD, _wintypes.HANDLE]
|
||||
create_file, close_handle = kernel32.CreateFileW, kernel32.CloseHandle
|
||||
dword = _wintypes.DWORD
|
||||
create_file.argtypes = [_wintypes.LPCWSTR, dword, dword, _wintypes.LPVOID, dword, dword,
|
||||
_wintypes.HANDLE]
|
||||
create_file.restype = _wintypes.HANDLE
|
||||
close_handle = kernel32.CloseHandle
|
||||
close_handle.argtypes = [_wintypes.HANDLE]
|
||||
close_handle.restype = _wintypes.BOOL
|
||||
|
||||
close_handle.argtypes, close_handle.restype = [_wintypes.HANDLE], _wintypes.BOOL
|
||||
handle = create_file(
|
||||
str(lock_file), generic_read | generic_write | delete_access, 0, # 0 = FileShare::None
|
||||
None, open_existing, file_attribute_normal | file_flag_delete_on_close, None)
|
||||
if handle == _wintypes.HANDLE(-1).value:
|
||||
logger.debug(
|
||||
"Windows cua install lock at %s is still held or cannot be removed (winerror %s)",
|
||||
lock_file, _ctypes.get_last_error())
|
||||
logger.debug("Windows cua install lock at %s is still held or cannot be removed "
|
||||
"(winerror %s)", lock_file, _ctypes.get_last_error())
|
||||
return
|
||||
if not close_handle(handle):
|
||||
logger.debug(
|
||||
"could not close Windows cua install lock probe at %s (winerror %s)",
|
||||
lock_file, _ctypes.get_last_error())
|
||||
logger.debug("could not close Windows cua install lock probe at %s (winerror %s)",
|
||||
lock_file, _ctypes.get_last_error())
|
||||
return
|
||||
if lock_file.exists():
|
||||
logger.debug("Windows cua install lock probe succeeded but %s remains", lock_file)
|
||||
return
|
||||
|
||||
logger.info("Cleared stale Windows cua-driver install lock at %s", lock_file)
|
||||
_print_info(f" Cleared stale cua-driver install lock ({lock_file}).")
|
||||
except Exception as e:
|
||||
@@ -429,8 +403,8 @@ def _clear_stale_windows_cua_install_lock() -> None:
|
||||
def _clear_stale_cua_install_lock() -> None:
|
||||
"""Best-effort: remove a stale installer lock left by a dead holder.
|
||||
POSIX stamps the holder pid into ``~/.cua-driver/packages/.install.lock.d/info``; Windows holds
|
||||
``~/.cua-driver/install.lock`` open with ``FileShare::None``. Clear either artifact up front only
|
||||
when its platform-specific liveness check proves that no install still holds it."""
|
||||
``~/.cua-driver/install.lock`` open with ``FileShare::None``. Clear either artifact up front
|
||||
only when its platform-specific liveness check proves that no install still holds it."""
|
||||
if sys.platform == "win32":
|
||||
_clear_stale_windows_cua_install_lock()
|
||||
return
|
||||
@@ -438,15 +412,12 @@ def _clear_stale_cua_install_lock() -> None:
|
||||
try:
|
||||
if not lock_dir.is_dir():
|
||||
return
|
||||
holder_pid = None
|
||||
try:
|
||||
for line in (lock_dir / "info").read_text(encoding="utf-8", errors="replace").splitlines():
|
||||
if line.startswith("pid="):
|
||||
holder_pid = int(line.split("=", 1)[1].strip())
|
||||
break
|
||||
lines = (lock_dir / "info").read_text(encoding="utf-8", errors="replace").splitlines()
|
||||
holder_pid = next((int(line.split("=", 1)[1].strip()) for line in lines
|
||||
if line.startswith("pid=")), None)
|
||||
except (OSError, ValueError):
|
||||
holder_pid = None
|
||||
|
||||
if holder_pid is not None:
|
||||
try:
|
||||
os.kill(holder_pid, 0) # windows-footgun: ok — function early-returns on win32
|
||||
@@ -457,14 +428,11 @@ def _clear_stale_cua_install_lock() -> None:
|
||||
return # alive but owned by someone else — treat as live
|
||||
else:
|
||||
# No readable pid: only clear if old enough that upstream itself would reclaim it.
|
||||
import time as _time
|
||||
try:
|
||||
age = _time.time() - lock_dir.stat().st_mtime
|
||||
if time.time() - lock_dir.stat().st_mtime < _CUA_LOCK_STALE_AFTER:
|
||||
return
|
||||
except OSError:
|
||||
return
|
||||
if age < _CUA_LOCK_STALE_AFTER:
|
||||
return
|
||||
|
||||
shutil.rmtree(lock_dir, ignore_errors=True)
|
||||
logger.info("Cleared stale cua-driver install lock at %s", lock_dir)
|
||||
_print_info(f" Cleared stale cua-driver install lock ({lock_dir}).")
|
||||
@@ -482,8 +450,8 @@ def _cua_install_lock_held() -> bool:
|
||||
lock_file = _cua_windows_install_lock_file()
|
||||
if not lock_file.is_file():
|
||||
return False
|
||||
# install.ps1 holds the file with FileShare::None — any open fails with a sharing violation
|
||||
# while held. Surviving the stale-clear = held; confirm with an open probe.
|
||||
# install.ps1 holds the file with FileShare::None — any open fails with a sharing
|
||||
# violation while held. Surviving the stale-clear = held; confirm with an open probe.
|
||||
try:
|
||||
with open(lock_file, "r+b"):
|
||||
return False # opened fine → not held (racy leftover)
|
||||
@@ -501,7 +469,6 @@ def _cua_release_endpoint_reachable(timeout: float = 5.0) -> bool:
|
||||
unreachable — any HTTP response (even 4xx/5xx) proves the path works."""
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
|
||||
try:
|
||||
req = urllib.request.Request("https://github.com/trycua/cua/releases", method="HEAD")
|
||||
with urllib.request.urlopen(req, timeout=timeout):
|
||||
@@ -523,65 +490,47 @@ def _cua_driver_autostart_registered_windows() -> bool:
|
||||
if sys.platform != "win32":
|
||||
return False
|
||||
try:
|
||||
result = subprocess.run(
|
||||
["schtasks.exe", "/Query", "/TN", "cua-driver-serve"],
|
||||
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=10)
|
||||
return subprocess.run(["schtasks.exe", "/Query", "/TN", "cua-driver-serve"],
|
||||
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
|
||||
timeout=10).returncode == 0
|
||||
except Exception:
|
||||
return False
|
||||
return result.returncode == 0
|
||||
|
||||
|
||||
def _repair_cua_driver_autostart_windows(driver_cmd: str, *, verbose: bool) -> bool:
|
||||
"""Best-effort repair for Windows installer autostart quoting failures.
|
||||
Older install.ps1 builds interpolated the binary path into a PowerShell command string, which split
|
||||
at the first space. If the scheduled task is missing, retry via Start-Process's structured
|
||||
``-FilePath`` / ``-ArgumentList`` parameters instead."""
|
||||
Older install.ps1 builds interpolated the binary path into a PowerShell command string, which
|
||||
split at the first space. If the scheduled task is missing, retry via Start-Process's
|
||||
structured ``-FilePath`` / ``-ArgumentList`` parameters instead."""
|
||||
if sys.platform != "win32" or _cua_driver_autostart_registered_windows():
|
||||
return True
|
||||
|
||||
binary = shutil.which(driver_cmd)
|
||||
if not binary:
|
||||
return False
|
||||
|
||||
ps = shutil.which("powershell") or shutil.which("powershell.exe") or "powershell"
|
||||
ps_cmd = (
|
||||
f"$exe = {_ps_single_quote(binary)}; "
|
||||
"$proc = Start-Process -FilePath $exe "
|
||||
"-ArgumentList @('autostart','enable') "
|
||||
"-Verb RunAs -Wait -PassThru -ErrorAction Stop; "
|
||||
"exit $proc.ExitCode")
|
||||
_print_info(" Registering cua-driver auto-start..." if verbose else " Repairing cua-driver auto-start registration...")
|
||||
|
||||
ps_cmd = (f"$exe = {_ps_single_quote(binary)}; "
|
||||
"$proc = Start-Process -FilePath $exe -ArgumentList @('autostart','enable') "
|
||||
"-Verb RunAs -Wait -PassThru -ErrorAction Stop; exit $proc.ExitCode")
|
||||
_print_info(" Registering cua-driver auto-start..." if verbose
|
||||
else " Repairing cua-driver auto-start registration...")
|
||||
try:
|
||||
result = _run_text([ps, "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", ps_cmd], timeout=300,
|
||||
env=_cua_driver_env())
|
||||
result = _run_text([ps, "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", ps_cmd],
|
||||
timeout=300, env=_cua_driver_env())
|
||||
except subprocess.TimeoutExpired:
|
||||
_print_warning(" cua-driver autostart registration timed out.")
|
||||
return False
|
||||
return _fail(" cua-driver autostart registration timed out.")
|
||||
except Exception as exc:
|
||||
_print_warning(f" cua-driver autostart registration failed: {exc}")
|
||||
return False
|
||||
|
||||
return _fail(f" cua-driver autostart registration failed: {exc}")
|
||||
if result.returncode == 0:
|
||||
return True
|
||||
|
||||
_print_warning(" cua-driver autostart registration failed.")
|
||||
for line in (result.stderr or result.stdout or "").strip().splitlines()[-3:]:
|
||||
_print_info(f" {line[:200]}")
|
||||
_print_output_tail(result)
|
||||
_print_info(" From an elevated shell, run: cua-driver autostart enable")
|
||||
return False
|
||||
|
||||
|
||||
def _remove_quietly(path: str) -> None:
|
||||
try:
|
||||
with contextlib.suppress(OSError):
|
||||
os.remove(path)
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
|
||||
_MAC_PERMISSION_PATHS = (
|
||||
" System Settings > Privacy & Security > Accessibility",
|
||||
" System Settings > Privacy & Security > Screen Recording")
|
||||
|
||||
|
||||
def _print_cua_platform_notes(is_windows: bool, is_linux: bool, *, fresh_install: bool) -> None:
|
||||
@@ -594,8 +543,8 @@ def _print_cua_platform_notes(is_windows: bool, is_linux: bool, *, fresh_install
|
||||
else:
|
||||
_print_info(" IMPORTANT — grant macOS permissions now:" if fresh_install
|
||||
else " Grant macOS permissions if not done yet:")
|
||||
for line in _MAC_PERMISSION_PATHS:
|
||||
_print_info(line)
|
||||
_print_info(" System Settings > Privacy & Security > Accessibility")
|
||||
_print_info(" System Settings > Privacy & Security > Screen Recording")
|
||||
if fresh_install:
|
||||
_print_info(" Both must allow the terminal / Hermes process.")
|
||||
|
||||
@@ -605,23 +554,22 @@ def _kill_installer_tree(proc, *, is_windows: bool) -> None:
|
||||
import signal as _signal
|
||||
try:
|
||||
if not is_windows:
|
||||
os.killpg(os.getpgid(proc.pid), _signal.SIGKILL) # windows-footgun: ok — POSIX branch only
|
||||
os.killpg(os.getpgid(proc.pid), _signal.SIGKILL) # windows-footgun: ok — POSIX only
|
||||
return
|
||||
# PowerShell may leave download/install helpers alive after its direct process is killed. They
|
||||
# inherit stdout and can keep communicate() and install.lock wedged, so kill the tree leaf-up.
|
||||
# PowerShell may leave download/install helpers alive after its direct process is killed;
|
||||
# they inherit stdout and can keep communicate() and install.lock wedged → kill leaf-up.
|
||||
import psutil as _psutil
|
||||
|
||||
try:
|
||||
parent = _psutil.Process(proc.pid)
|
||||
descendants = parent.children(recursive=True)
|
||||
except _psutil.NoSuchProcess:
|
||||
return
|
||||
except _psutil.Error as e:
|
||||
logger.debug("could not enumerate cua-driver installer tree for pid %s: %s", proc.pid, e)
|
||||
logger.debug("could not enumerate cua-driver installer tree for pid %s: %s",
|
||||
proc.pid, e)
|
||||
proc.kill()
|
||||
return
|
||||
|
||||
for target, pid in [(child, child.pid) for child in reversed(descendants)] + [(parent, proc.pid)]:
|
||||
for target, pid in [(c, c.pid) for c in reversed(descendants)] + [(parent, proc.pid)]:
|
||||
try:
|
||||
target.kill()
|
||||
except _psutil.NoSuchProcess:
|
||||
@@ -637,38 +585,37 @@ def _kill_installer_tree(proc, *, is_windows: bool) -> None:
|
||||
|
||||
def _reap_after_timeout(proc, *, is_windows: bool) -> None:
|
||||
"""Kill the installer tree, then drain its pipes under a deadline.
|
||||
An unbounded drain blocks on an EOF that only arrives when someone kills a surviving descendant by
|
||||
hand, so ``_CUA_INSTALLER_TIMEOUT`` would stop bounding anything."""
|
||||
An unbounded drain blocks on an EOF that only arrives when someone kills a surviving descendant
|
||||
by hand, so ``_CUA_INSTALLER_TIMEOUT`` would stop bounding anything."""
|
||||
_kill_installer_tree(proc, is_windows=is_windows)
|
||||
try:
|
||||
drained_out, _ = proc.communicate(timeout=_CUA_INSTALLER_DRAIN_GRACE)
|
||||
# The partial output names WHERE the installer was stuck (lock wait, consent prompt, download).
|
||||
# Partial output names WHERE the installer was stuck (lock wait, consent prompt, download).
|
||||
if drained_out:
|
||||
logger.warning("cua-driver installer timed out; last output before kill:\n%s", drained_out[-2000:])
|
||||
logger.warning("cua-driver installer timed out; last output before kill:\n%s",
|
||||
drained_out[-2000:])
|
||||
except subprocess.TimeoutExpired:
|
||||
# Deliberately not closing proc.stdout: communicate()'s reader threads are still blocked on that
|
||||
# handle and closing it underneath them races; they are daemon threads.
|
||||
logger.debug(
|
||||
"cua-driver installer pipes still open %ss after the kill — "
|
||||
"abandoning the drain, a surviving descendant holds the inherited handle",
|
||||
_CUA_INSTALLER_DRAIN_GRACE)
|
||||
# Deliberately not closing proc.stdout: communicate()'s reader threads are still blocked on
|
||||
# that handle and closing it underneath them races; they are daemon threads.
|
||||
logger.debug("cua-driver installer pipes still open %ss after the kill — "
|
||||
"abandoning the drain, a surviving descendant holds the inherited handle",
|
||||
_CUA_INSTALLER_DRAIN_GRACE)
|
||||
except (OSError, ValueError) as e:
|
||||
logger.debug("cua-driver installer drain failed: %s", e)
|
||||
|
||||
|
||||
def _cua_installer_command(is_windows: bool):
|
||||
"""Return ``(install_cmd, manual_hint, script_path)`` or None when the POSIX download fails."""
|
||||
"""Return ``(install_cmd, manual_hint, script_path)``; all None if the POSIX download fails."""
|
||||
if is_windows:
|
||||
# Mirror the one-liner printed by cua_driver_install_hint().
|
||||
ps_oneliner = f"irm {_CUA_INSTALL_PS1_URL} | iex"
|
||||
install_cmd = ["powershell", "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", ps_oneliner]
|
||||
return install_cmd, f'powershell -NoProfile -ExecutionPolicy Bypass -Command "{ps_oneliner}"', None
|
||||
ps_oneliner = f"irm {_CUA_INSTALL_PS1_URL} | iex" # mirrors cua_driver_install_hint()
|
||||
return (["powershell", "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", ps_oneliner],
|
||||
f'powershell -NoProfile -ExecutionPolicy Bypass -Command "{ps_oneliner}"', None)
|
||||
|
||||
# Download-then-exec instead of `bash -c "$(curl …)"`: no shell=True, no command substitution, and the
|
||||
# script lands in a mkstemp file (unpredictable name, 0600) rather than a fixed /tmp path — avoiding
|
||||
# both shell injection and a symlink/TOCTOU race. The manual hint stays the upstream one-liner.
|
||||
# Download-then-exec instead of `bash -c "$(curl …)"`: no shell=True, no command substitution,
|
||||
# and the script lands in a mkstemp file (unpredictable name, 0600) rather than a fixed /tmp
|
||||
# path — avoiding both shell injection and a symlink/TOCTOU race. The manual hint stays the
|
||||
# upstream one-liner.
|
||||
import tempfile as _tempfile
|
||||
|
||||
manual_hint = f'/bin/bash -c "$(curl -fsSL {_CUA_INSTALL_SH_URL})"'
|
||||
fd, script_path = _tempfile.mkstemp(prefix="cua-driver-install-", suffix=".sh")
|
||||
os.close(fd)
|
||||
@@ -680,66 +627,93 @@ def _cua_installer_command(is_windows: bool):
|
||||
if failure is not None:
|
||||
_print_warning(f" cua-driver installer download failed: {failure}")
|
||||
_remove_quietly(script_path)
|
||||
return None
|
||||
return None, None, None
|
||||
return ["/bin/bash", script_path], manual_hint, script_path
|
||||
|
||||
|
||||
def _unattended_installer_preflight(install_cmd: list, is_windows: bool):
|
||||
"""Fail FAST on the two conditions that otherwise consume the whole unattended ceiling.
|
||||
1. Install lock held by a live process — upstream would poll it for up to
|
||||
LOCK_STALE_AFTER_SECONDS=600 before probing the holder (the 11-minute silent hang class).
|
||||
2. Release host unreachable — the installer would die slowly inside its own retries; a 5s HEAD
|
||||
answers. Returns the (possibly rewritten) install command, or None to skip this refresh. Explicit
|
||||
`computer-use install --upgrade` runs never come here and keep upstream's full lock-recovery."""
|
||||
"""Fail FAST on the two conditions that otherwise consume the whole unattended ceiling:
|
||||
(1) install lock held by a live process — upstream would poll it for up to
|
||||
LOCK_STALE_AFTER_SECONDS=600 before probing the holder (the 11-minute silent hang class);
|
||||
(2) release host unreachable — the installer dies slowly inside its own retries; a 5s HEAD
|
||||
answers. Returns the (possibly rewritten) install command, or None to skip this refresh.
|
||||
Explicit `install --upgrade` runs never come here and keep upstream's full lock-recovery."""
|
||||
if _cua_install_lock_held():
|
||||
_print_info(" Another cua-driver install is in progress (upstream install lock is held) — skipping this refresh.")
|
||||
_print_info(f" If no install is really running, retry with: {_UPGRADE_CMD}")
|
||||
_fail(" Another cua-driver install is in progress (upstream install lock is held) — "
|
||||
"skipping this refresh.",
|
||||
f" If no install is really running, retry with: {_UPGRADE_CMD}", warn=False)
|
||||
return None
|
||||
if not _cua_release_endpoint_reachable():
|
||||
_print_info(" github.com is unreachable — skipping cua-driver refresh (will retry on the next update).")
|
||||
_print_info(" github.com is unreachable — skipping cua-driver refresh "
|
||||
"(will retry on the next update).")
|
||||
return None
|
||||
if is_windows:
|
||||
# -NoAutoStart skips Register-CuaDriverAutostart — the ONLY branch of install.ps1 that self-elevates
|
||||
# (UAC). Cost: an existing cua-driver-serve task keeps pointing at the previous binary until the
|
||||
# next interactive upgrade. Scriptblock invocation (not `| iex`) is what lets us pass the parameter.
|
||||
# -NoAutoStart skips Register-CuaDriverAutostart — the ONLY branch of install.ps1 that
|
||||
# self-elevates (UAC). Cost: an existing cua-driver-serve task keeps pointing at the
|
||||
# previous binary until the next interactive upgrade. Scriptblock invocation (not `| iex`)
|
||||
# is what lets us pass the parameter.
|
||||
install_cmd = [
|
||||
"powershell", "-NoProfile", "-ExecutionPolicy", "Bypass",
|
||||
"-Command", f"$sc = irm {_CUA_INSTALL_PS1_URL}; & ([scriptblock]::Create($sc)) -NoAutoStart",
|
||||
]
|
||||
"powershell", "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command",
|
||||
f"$sc = irm {_CUA_INSTALL_PS1_URL}; & ([scriptblock]::Create($sc)) -NoAutoStart"]
|
||||
return install_cmd
|
||||
|
||||
|
||||
def _run_cua_driver_installer(
|
||||
label: str = "Installing", verbose: bool = True, pin_version: Optional[str] = None, show_progress: bool = True,
|
||||
installer_timeout: Optional[float] = None) -> bool:
|
||||
"""Run the upstream cua-driver installer for this platform.
|
||||
The scripts are idempotent: they always download the latest release, so re-running on an
|
||||
already-installed system performs an upgrade. ``installer_timeout`` lets quiet callers use a shorter
|
||||
ceiling without weakening the explicit install path's stale-lock recovery window."""
|
||||
import platform as _plat
|
||||
def _installer_popen_kwargs(is_windows: bool, verbose: bool, env: dict) -> dict:
|
||||
"""Popen kwargs for the upstream installer.
|
||||
POSIX: own process group so a timeout kill takes out the whole `curl | bash` pipeline (and the
|
||||
exec'd _install-rust.sh), not just the outer shell — surviving grandchildren would keep
|
||||
holding the install lock and wedge every later run. Non-verbose (`hermes update` refresh):
|
||||
capture the chatty "Next steps" wall and log it so a failure stays debuggable; verbose
|
||||
interactive installs stream live."""
|
||||
kwargs: dict = {"shell": False, "env": env}
|
||||
if not is_windows:
|
||||
kwargs["start_new_session"] = True
|
||||
if verbose:
|
||||
kwargs["creationflags"] = _post_setup_no_window_flags(streams_to_console=True)
|
||||
else:
|
||||
kwargs.update(stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
|
||||
text=True, encoding="utf-8", errors="replace",
|
||||
creationflags=_post_setup_no_window_flags())
|
||||
return kwargs
|
||||
|
||||
system = _plat.system()
|
||||
is_windows = system == "Windows"
|
||||
is_linux = system == "Linux"
|
||||
|
||||
prepared = _cua_installer_command(is_windows)
|
||||
if prepared is None:
|
||||
def _record_installer_output(out: str, returncode: int) -> None:
|
||||
"""Keep a captured (non-verbose) installer transcript without echoing it to the terminal.
|
||||
During `hermes update`, sys.stdout is the mirroring _UpdateOutputStream whose `_log` handle is
|
||||
~/.hermes/logs/update.log — write straight to it so the full output is kept (success AND
|
||||
failure)."""
|
||||
_update_log = getattr(sys.stdout, "_log", None)
|
||||
if _update_log is not None:
|
||||
try:
|
||||
_update_log.write("\n--- cua-driver installer output ---\n" + out + "\n")
|
||||
_update_log.flush()
|
||||
except Exception:
|
||||
pass
|
||||
if returncode != 0:
|
||||
logger.debug("cua-driver installer output:\n%s", out)
|
||||
|
||||
|
||||
def _run_cua_driver_installer(label: str = "Installing", verbose: bool = True,
|
||||
pin_version: Optional[str] = None, show_progress: bool = True,
|
||||
installer_timeout: Optional[float] = None) -> bool:
|
||||
"""Run the upstream cua-driver installer (idempotent: always the latest release, so re-running
|
||||
upgrades). ``installer_timeout`` lets quiet callers use a shorter ceiling without weakening the
|
||||
explicit install path's stale-lock recovery window."""
|
||||
system = platform.system()
|
||||
is_windows, is_linux = system == "Windows", system == "Linux"
|
||||
install_cmd, manual_hint, script_path = _cua_installer_command(is_windows)
|
||||
if install_cmd is None:
|
||||
return False
|
||||
install_cmd, manual_hint, script_path = prepared
|
||||
|
||||
if show_progress:
|
||||
_print_info(f" {label} cua-driver (background computer-use)..." if verbose
|
||||
else f"→ {label} cua-driver (Computer Use)...")
|
||||
driver_cmd = _cua_driver_cmd()
|
||||
timeout = _CUA_INSTALLER_TIMEOUT if installer_timeout is None else installer_timeout
|
||||
|
||||
installer_env = _cua_driver_env()
|
||||
if pin_version:
|
||||
# Both upstream installers honour CUA_DRIVER_RS_VERSION over their baked default.
|
||||
if pin_version: # both upstream installers honour CUA_DRIVER_RS_VERSION over the baked default
|
||||
installer_env["CUA_DRIVER_RS_VERSION"] = pin_version
|
||||
|
||||
# A previous timed-out install can leave upstream's concurrent-install lock behind; clear it when
|
||||
# provably stale so the refresh doesn't wedge waiting on a dead holder.
|
||||
# A previous timed-out install can leave upstream's concurrent-install lock behind; clear it
|
||||
# when provably stale so the refresh doesn't wedge waiting on a dead holder.
|
||||
_clear_stale_cua_install_lock()
|
||||
|
||||
# Unattended refreshes (installer_timeout set by `hermes update`) preflight and may skip.
|
||||
@@ -747,23 +721,7 @@ def _run_cua_driver_installer(
|
||||
install_cmd = _unattended_installer_preflight(install_cmd, is_windows)
|
||||
if install_cmd is None:
|
||||
return False
|
||||
|
||||
# POSIX: own process group so a timeout kill takes out the whole `curl | bash` pipeline (and the exec'd
|
||||
# _install-rust.sh), not just the outer shell — surviving grandchildren would keep holding the install
|
||||
# lock and wedge every later run.
|
||||
popen_kwargs: dict = {"shell": False, "env": installer_env}
|
||||
if not is_windows:
|
||||
popen_kwargs["start_new_session"] = True
|
||||
# Non-verbose (`hermes update` refresh): capture the installer's chatty "Next steps" wall and log it
|
||||
# so a failure stays debuggable. Verbose interactive installs stream live.
|
||||
if verbose:
|
||||
popen_kwargs["creationflags"] = _post_setup_no_window_flags(streams_to_console=True)
|
||||
else:
|
||||
popen_kwargs.update(
|
||||
stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
|
||||
text=True, encoding="utf-8", errors="replace", creationflags=_post_setup_no_window_flags(),
|
||||
)
|
||||
|
||||
popen_kwargs = _installer_popen_kwargs(is_windows, verbose, installer_env)
|
||||
try:
|
||||
proc = subprocess.Popen(install_cmd, **popen_kwargs)
|
||||
try:
|
||||
@@ -772,40 +730,28 @@ def _run_cua_driver_installer(
|
||||
_reap_after_timeout(proc, is_windows=is_windows)
|
||||
raise
|
||||
out = None if verbose else communicated[0]
|
||||
result = subprocess.CompletedProcess(install_cmd, proc.returncode, stdout=out, stderr=None)
|
||||
if not verbose and result.stdout:
|
||||
# During `hermes update`, sys.stdout is the mirroring _UpdateOutputStream whose `_log` handle is
|
||||
# ~/.hermes/logs/update.log — write straight to it so the full installer output is kept
|
||||
# (success AND failure) without echoing it to the terminal.
|
||||
_update_log = getattr(sys.stdout, "_log", None)
|
||||
if _update_log is not None:
|
||||
try:
|
||||
_update_log.write("\n--- cua-driver installer output ---\n" + result.stdout + "\n")
|
||||
_update_log.flush()
|
||||
except Exception:
|
||||
pass
|
||||
if result.returncode != 0:
|
||||
logger.debug("cua-driver installer output:\n%s", result.stdout)
|
||||
if out:
|
||||
_record_installer_output(out, proc.returncode)
|
||||
installed_binary = _resolved_cua_driver_cmd()
|
||||
if result.returncode == 0 and installed_binary:
|
||||
if is_windows and not _repair_cua_driver_autostart_windows(installed_binary, verbose=verbose):
|
||||
if proc.returncode == 0 and installed_binary:
|
||||
if is_windows and not _repair_cua_driver_autostart_windows(installed_binary,
|
||||
verbose=verbose):
|
||||
_print_warning(" cua-driver installed, but auto-start was not registered.")
|
||||
if verbose:
|
||||
_print_success(f" {driver_cmd} installed.")
|
||||
_print_cua_platform_notes(is_windows, is_linux, fresh_install=True)
|
||||
return True
|
||||
_print_warning(f" cua-driver {label.lower()} did not complete. Re-run manually:")
|
||||
_print_info(f" {manual_hint}")
|
||||
return False
|
||||
return _fail(f" cua-driver {label.lower()} did not complete. Re-run manually:",
|
||||
f" {manual_hint}")
|
||||
except subprocess.TimeoutExpired:
|
||||
_print_warning(f" cua-driver {label.lower()} timed out after {timeout}s.")
|
||||
if not is_windows:
|
||||
_print_info(f" If this repeats, a stale installer lock may be present — check {_cua_install_lock_dir()}")
|
||||
_print_info(" If this repeats, a stale installer lock may be present — check "
|
||||
f"{_cua_install_lock_dir()}")
|
||||
_print_info(f" Re-run manually: {manual_hint}")
|
||||
return False
|
||||
except Exception as e:
|
||||
_print_warning(f" cua-driver {label.lower()} failed: {e}")
|
||||
return False
|
||||
return _fail(f" cua-driver {label.lower()} failed: {e}")
|
||||
finally:
|
||||
if script_path:
|
||||
_remove_quietly(script_path)
|
||||
|
||||
@@ -277,7 +277,7 @@ def _configure_tool_category(ts_key: str, cat: dict, config: dict, *, force_fres
|
||||
try:
|
||||
_nous_logged_in = bool(get_nous_subscription_features(config, force_fresh=force_fresh).nous_auth_present)
|
||||
except Exception:
|
||||
_nous_logged_in = False
|
||||
pass
|
||||
|
||||
provider_choices = [] # plain text labels only (no ANSI codes in menu items)
|
||||
for p in providers:
|
||||
@@ -349,8 +349,7 @@ def _managed_provider_active(provider: dict, config: dict, managed_feature: str,
|
||||
provider must be the row's vendor or ``nous``."""
|
||||
from hermes_cli.tools_config import get_nous_subscription_features
|
||||
|
||||
features = get_nous_subscription_features(config, force_fresh=force_fresh)
|
||||
feature = features.features.get(managed_feature)
|
||||
feature = get_nous_subscription_features(config, force_fresh=force_fresh).features.get(managed_feature)
|
||||
if feature is None:
|
||||
return False
|
||||
if managed_feature in ("image_gen", "video_gen"):
|
||||
@@ -644,8 +643,7 @@ def _configure_stt_model(stt_provider: str, config: dict) -> None:
|
||||
model_key = _STT_MODEL_CONFIG_KEY.get(stt_provider, "model")
|
||||
current = str(prov_cfg.get(model_key) or "").strip()
|
||||
ordered = list(catalog)
|
||||
default_idx = ordered.index(current) if current in ordered else 0
|
||||
chosen = ordered[_prompt_choice(" Select STT model:", ordered, default_idx)]
|
||||
chosen = ordered[_prompt_choice(" Select STT model:", ordered, ordered.index(current) if current in ordered else 0)]
|
||||
prov_cfg[model_key] = chosen
|
||||
_print_success(f" STT model set to: {chosen}")
|
||||
|
||||
@@ -846,9 +844,9 @@ def _prompt_secret(
|
||||
if url:
|
||||
_print_info(f" {url_label}: {url}")
|
||||
if reconfigure:
|
||||
value = _prompt(f" {label} (Enter to keep current)", password=not default_val)
|
||||
if value and value.strip():
|
||||
save_env_value(key, value.strip())
|
||||
value = (_prompt(f" {label} (Enter to keep current)", password=not default_val) or "").strip()
|
||||
if value:
|
||||
save_env_value(key, value)
|
||||
_print_success(" Updated")
|
||||
else:
|
||||
_print_info(" Kept current")
|
||||
@@ -1002,15 +1000,12 @@ def _configure_vision_provider_model(config: dict, vision_cfg: dict) -> None:
|
||||
providers = []
|
||||
|
||||
if not providers:
|
||||
_print_warning(
|
||||
" No authenticated providers found. Configure a provider first "
|
||||
"with `hermes model`, then re-run this.")
|
||||
_print_warning(" No authenticated providers found. Configure a provider first "
|
||||
"with `hermes model`, then re-run this.")
|
||||
return
|
||||
|
||||
provider_labels = [label for _slug, label, _models in format_aux_picker_entries(
|
||||
providers, current_provider=current_provider, current_base_url=current_base_url)]
|
||||
provider_labels.append("Cancel")
|
||||
|
||||
providers, current_provider=current_provider, current_base_url=current_base_url)] + ["Cancel"]
|
||||
pidx = _prompt_choice(" Choose vision provider:", provider_labels, 0)
|
||||
if pidx >= len(providers):
|
||||
_print_info(" Cancelled")
|
||||
@@ -1019,8 +1014,7 @@ def _configure_vision_provider_model(config: dict, vision_cfg: dict) -> None:
|
||||
chosen = providers[pidx]
|
||||
slug = chosen.get("slug")
|
||||
models = list(chosen.get("models", []))
|
||||
model_choices = list(models) + ["Type a custom model id…"]
|
||||
midx = _prompt_choice(f" Choose vision model for {chosen.get('name') or slug}:", model_choices, 0)
|
||||
midx = _prompt_choice(f" Choose vision model for {chosen.get('name') or slug}:", models + ["Type a custom model id…"], 0)
|
||||
if midx < len(models):
|
||||
model = models[midx]
|
||||
else:
|
||||
|
||||
Reference in New Issue
Block a user