@inline-chat/hermes-agent-adapter 0.0.18-alpha.0 → 0.0.19

package/plugin/inline/adapter.py

@@ -22,7 +22,6 @@ import signal
 import socket
 import subprocess
 import sys
-import threading
 import time
 from collections import OrderedDict
 from datetime import datetime, timezone
@@ -45,6 +44,7 @@ from gateway.platforms.base import (
     SendResult,
     cache_audio_from_url,
     cache_image_from_url,
+    safe_url_for_log,
 )
 from gateway.platforms.helpers import strip_markdown
 
@@ -106,15 +106,8 @@ _INLINE_THREADS_COMMAND_DESCRIPTION = "Configure Inline reply-thread routing"
 _INLINE_THREADS_COMMAND_ARGS = "[status|on|off|auto|reset]"
 _INLINE_FOLLOW_COMMAND_DESCRIPTION = "Explicitly follow this Inline chat or thread"
 _INLINE_UNFOLLOW_COMMAND_DESCRIPTION = "Explicitly unfollow this Inline chat or thread"
-_INLINE_UPDATE_COMMAND_DESCRIPTION = "Update the Inline Hermes plugin"
 _INLINE_SYNC_COMMAND_DESCRIPTION = "Resync Inline commands and skills"
 _INLINE_VERSION_COMMAND_DESCRIPTION = "Show Inline plugin and sync information"
-_INLINE_UPDATE_PACKAGE_NAME = "@inline-chat/hermes-agent-adapter"
-_INLINE_UPDATE_PRECHECK_TIMEOUT_SECONDS = 30
-_INLINE_UPDATE_TIMEOUT_SECONDS = 5 * 60
-_INLINE_UPDATE_LOG_MAX_LINES = 80
-_INLINE_UPDATE_LOG_MAX_CHARS = 8_000
-_INLINE_UPDATE_LOCK = threading.Lock()
 _INLINE_THREADS_ACTION_PREFIX = "th:"
 _INLINE_THREADS_ACTION_TTL_SECONDS = 15 * 60
 _INLINE_THREAD_COMMAND_RE = re.compile(r"^/(?:thread|threads)(?:@[A-Za-z0-9_]+)?(?:\s+(.*))?$", re.IGNORECASE)
@@ -575,7 +568,7 @@ def _normalize_inline_command_description(raw: str) -> str:
 
 
 def _inline_menu_commands(max_commands: int = _INLINE_COMMAND_LIMIT) -> tuple[List[Dict[str, Any]], int]:
-    from hermes_cli.commands import telegram_menu_commands
+    from hermes_cli.commands_platforms import telegram_menu_commands
 
     command_specs = _inline_command_specs()
     local_commands = [
@@ -1209,7 +1202,7 @@ class InlineAdapter(BasePlatformAdapter):
 
         try:
             from gateway.run import _load_gateway_config
-            from hermes_cli.model_switch import list_picker_providers
+            from hermes_cli.model_switch_providers import list_picker_providers
 
             cfg = _load_gateway_config() or {}
             model_cfg = cfg.get("model") if isinstance(cfg, dict) else {}
@@ -3001,16 +2994,15 @@ class InlineAdapter(BasePlatformAdapter):
                 return await cache_audio_from_url(url, ext=_extension_for_media(mime, file_name, ".ogg"))
             return await self._download_inline_media_url(url, mime=mime, file_name=file_name)
         except Exception as exc:
-            logger.warning("[inline] failed to cache %s attachment: %s", kind, exc)
-            return url
+            logger.warning("[inline] failed to cache %s attachment (%s)", kind, type(exc).__name__)
+            # Never pass an unvalidated URL on to Hermes for another fetch.
+            return None
 
     async def _download_inline_media_url(self, url: str, *, mime: str, file_name: Optional[str]) -> str:
-        try:
-            from tools.url_safety import is_safe_url, safe_url_for_log
-            if not is_safe_url(url):
-                raise ValueError(f"blocked unsafe media URL: {safe_url_for_log(url)}")
-        except ImportError:
-            pass
+        # A missing host safety helper must stop the download, never bypass it.
+        from tools.url_safety import is_safe_url
+        if not is_safe_url(url):
+            raise ValueError(f"blocked unsafe media URL: {safe_url_for_log(url)}")
         _MEDIA_CACHE_DIR.mkdir(parents=True, exist_ok=True)
         name = _safe_media_file_name(url=url, mime=mime, file_name=file_name)
         path = _MEDIA_CACHE_DIR / name
@@ -4230,7 +4222,7 @@ class InlineAdapter(BasePlatformAdapter):
         label = group_id
         member_slugs: list[str] = []
         try:
-            from hermes_cli.models import PROVIDER_GROUPS
+            from hermes_cli.models_catalog_static import PROVIDER_GROUPS
             label, _desc, members = PROVIDER_GROUPS.get(group_id, (group_id, "", []))
             member_slugs = [str(member) for member in members]
         except Exception:
@@ -4686,7 +4678,6 @@ class InlineAdapter(BasePlatformAdapter):
 
     async def send_image(self, chat_id: str, image_url: str, caption: Optional[str] = None, reply_to: Optional[str] = None, metadata: Optional[Dict[str, Any]] = None) -> SendResult:
         try:
-            from gateway.platforms.base import cache_image_from_url
             local_path = await cache_image_from_url(image_url)
             return await self.send_image_file(chat_id, local_path, caption, reply_to, metadata)
         except Exception:
@@ -4694,7 +4685,6 @@ class InlineAdapter(BasePlatformAdapter):
 
     async def send_animation(self, chat_id: str, animation_url: str, caption: Optional[str] = None, reply_to: Optional[str] = None, metadata: Optional[Dict[str, Any]] = None) -> SendResult:
         try:
-            from gateway.platforms.base import cache_image_from_url
             local_path = await cache_image_from_url(animation_url, ext=".gif")
             return await self.send_document(chat_id, local_path, caption, file_name=Path(local_path).name, reply_to=reply_to, metadata=metadata)
         except Exception:
@@ -4982,7 +4972,7 @@ class InlineAdapter(BasePlatformAdapter):
         }
         actions: list[Dict[str, str]] = []
         try:
-            from hermes_cli.models import group_providers
+            from hermes_cli.models_catalog_static import group_providers
             grouped = group_providers(list(by_slug.keys()))
         except Exception:
             grouped = [{"kind": "single", "slug": slug} for slug in by_slug.keys()]
@@ -5319,67 +5309,8 @@ def _inline_unfollow_command_handler(raw_args: str = "") -> str:
     return _inline_follow_command_fallback("unfollow", raw_args)
 
 
-def _inline_update_environment() -> Dict[str, str]:
-    try:
-        from tools.environments.local import _sanitize_subprocess_env
-        env = _sanitize_subprocess_env(os.environ.copy())
-    except Exception:
-        env = os.environ.copy()
-    # Hermes cannot know the secret names introduced by every external plugin.
-    sensitive_names = ("TOKEN", "SECRET", "PASSWORD", "API_KEY", "AUTHORIZATION")
-    for key in list(env):
-        if any(name in key.upper() for name in sensitive_names):
-            env.pop(key, None)
-    return env
-
-
-def _inline_update_log_text(raw: Any, hermes_home: Optional[Path] = None) -> str:
-    text = str(raw or "")
-    text = re.sub(r"\x1b\[[0-?]*[ -/]*[@-~]", "", text)
-    text = re.sub(r"(?i)\b(Bearer\s+)[^\s]+", r"\1[REDACTED]", text)
-    text = re.sub(r"(?i)(https?://)[^/\s:@]+:[^@\s/]+@", r"\1[REDACTED]@", text)
-    text = re.sub(r"([?&][^=\s&]+)=([^&\s]+)", r"\1=[REDACTED]", text)
-    text = re.sub(
-        r"(?i)\b([A-Za-z0-9_-]*(?:token|secret|password|api[_-]?key|authorization)[A-Za-z0-9_-]*)\s*([=:])\s*[^\s]+",
-        r"\1\2[REDACTED]",
-        text,
-    )
-    sensitive_names = ("TOKEN", "SECRET", "PASSWORD", "API_KEY", "AUTHORIZATION")
-    for key, value in os.environ.items():
-        if len(value) >= 8 and any(name in key.upper() for name in sensitive_names):
-            text = text.replace(value, "[REDACTED]")
-    private_paths = []
-    if hermes_home:
-        private_paths.append((str(hermes_home), "$HERMES_HOME"))
-    private_paths.append((str(Path.home()), "~"))
-    for path_text, replacement in private_paths:
-        if len(path_text) > 1:
-            text = text.replace(path_text, replacement)
-    text = "".join(char if char in "\n\t" or ord(char) >= 32 else "?" for char in text)
-    lines = [line.rstrip() for line in text.splitlines() if line.strip()]
-    text = "\n".join(lines[-_INLINE_UPDATE_LOG_MAX_LINES:])
-    if len(text) > _INLINE_UPDATE_LOG_MAX_CHARS:
-        text = "[earlier output truncated]\n" + text[-_INLINE_UPDATE_LOG_MAX_CHARS:]
-    return text or "(no subprocess output)"
-
-
-def _log_inline_update_failure(
-    stage: str,
-    detail: str,
-    *,
-    output: Any = None,
-    hermes_home: Optional[Path] = None,
-) -> None:
-    diagnostic = f"{detail}\n{output or ''}".strip()
-    logger.error(
-        "[inline-update] stage=%s failed\n%s",
-        stage,
-        _inline_update_log_text(diagnostic, hermes_home),
-    )
-
-
-def _installed_inline_plugin_version(hermes_home: Path) -> Optional[str]:
-    manifest = hermes_home / "plugins" / "inline" / "plugin.yaml"
+def _installed_inline_plugin_version() -> Optional[str]:
+    manifest = Path(__file__).resolve().with_name("plugin.yaml")
     try:
         text = manifest.read_text(encoding="utf-8")
     except OSError:
@@ -5388,8 +5319,8 @@ def _installed_inline_plugin_version(hermes_home: Path) -> Optional[str]:
     return match.group(1) if match else None
 
 
-def _inline_install_timestamp(hermes_home: Path) -> Optional[str]:
-    target = hermes_home / "plugins" / "inline"
+def _inline_install_timestamp() -> Optional[str]:
+    target = Path(__file__).resolve().parent
     try:
         timestamp = target.lstat().st_ctime
     except OSError:
@@ -5406,21 +5337,13 @@ def _inline_catalog_part_summary(part: Dict[str, Any]) -> str:
 
 
 def _inline_version_text(last_sync: Optional[Dict[str, Any]] = None) -> str:
-    hermes_home = Path(os.getenv("HERMES_HOME") or Path.home() / ".hermes").expanduser()
-    version = _installed_inline_plugin_version(hermes_home)
-    if not version:
-        try:
-            manifest = Path(__file__).with_name("plugin.yaml").read_text(encoding="utf-8")
-        except OSError:
-            manifest = ""
-        match = re.search(r"(?m)^version:\s*['\"]?([^\s'\"]+)", manifest)
-        version = match.group(1) if match else None
+    version = _installed_inline_plugin_version()
     try:
         from hermes_cli import __version__ as hermes_version
     except Exception:
         hermes_version = None
 
-    installed_at = _inline_install_timestamp(hermes_home)
+    installed_at = _inline_install_timestamp()
     if last_sync:
         sync_text = (
             f"{last_sync.get('completed_at') or 'unknown'} "
@@ -5439,178 +5362,6 @@ def _inline_version_text(last_sync: Optional[Dict[str, Any]] = None) -> str:
     ])
 
 
-def _inline_update_lane(version: Optional[str]) -> Optional[str]:
-    if not version:
-        return None
-    match = re.fullmatch(r"\d+\.\d+\.\d+(?:-([A-Za-z][A-Za-z0-9-]*)(?:\.[0-9A-Za-z-]+)*)?", version)
-    if not match:
-        return None
-    return match.group(1) or "latest"
-
-
-def _semver_core(version: Any) -> Optional[tuple[int, int, int]]:
-    match = re.match(r"^v?(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$", str(version or "").strip())
-    if not match:
-        return None
-    return tuple(int(part) for part in match.groups())
-
-
-def _run_inline_update() -> str:
-    if not _INLINE_UPDATE_LOCK.acquire(blocking=False):
-        return "An Inline plugin update is already running."
-    try:
-        return _run_inline_update_locked()
-    finally:
-        _INLINE_UPDATE_LOCK.release()
-
-
-def _run_inline_update_locked() -> str:
-    hermes_home = Path(os.getenv("HERMES_HOME") or Path.home() / ".hermes").expanduser()
-    npm_bin = shutil.which("npm")
-    if not npm_bin:
-        _log_inline_update_failure("precheck", "npm was not found on PATH", hermes_home=hermes_home)
-        return "Inline plugin update is unavailable because npm was not found on PATH. Details were written to Hermes logs under `[inline-update]`."
-
-    target = hermes_home / "plugins" / "inline"
-    if target.is_symlink():
-        return (
-            "Inline is installed as a development symlink, so automatic update was skipped. "
-            "Update the linked source checkout and restart Hermes instead."
-        )
-
-    installed_version = _installed_inline_plugin_version(hermes_home)
-    lane = _inline_update_lane(installed_version)
-    if not lane:
-        return (
-            "Inline plugin update could not determine the installed release channel. "
-            "Update it manually with the package version or npm dist-tag you want to follow."
-        )
-    package_spec = f"{_INLINE_UPDATE_PACKAGE_NAME}@{lane}"
-    precheck_command = [npm_bin, "view", package_spec, "--json"]
-    try:
-        precheck = subprocess.run(
-            precheck_command,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-            timeout=_INLINE_UPDATE_PRECHECK_TIMEOUT_SECONDS,
-            check=False,
-            env=_inline_update_environment(),
-        )
-    except subprocess.TimeoutExpired as exc:
-        _log_inline_update_failure(
-            "precheck",
-            "npm view timed out",
-            output=f"{exc.stdout or ''}\n{exc.stderr or ''}",
-            hermes_home=hermes_home,
-        )
-        return "Inline plugin compatibility precheck timed out; no update was applied. Details were written to Hermes logs under `[inline-update]`."
-    except OSError as exc:
-        _log_inline_update_failure("precheck", f"npm view could not start: {exc}", hermes_home=hermes_home)
-        return "Inline plugin compatibility precheck could not start; no update was applied. Details were written to Hermes logs under `[inline-update]`."
-    if precheck.returncode != 0:
-        _log_inline_update_failure(
-            "precheck",
-            f"npm view exited with code {precheck.returncode} for {package_spec}",
-            output=f"{precheck.stdout or ''}\n{precheck.stderr or ''}",
-            hermes_home=hermes_home,
-        )
-        return (
-            f"Inline plugin compatibility precheck failed with exit code {precheck.returncode}; "
-            "no update was applied. Details were written to Hermes logs under `[inline-update]`."
-        )
-    try:
-        package_metadata = json.loads(precheck.stdout or "{}")
-    except (TypeError, json.JSONDecodeError):
-        package_metadata = None
-    inline_metadata = package_metadata.get("inlineHermes") if isinstance(package_metadata, dict) else None
-    candidate_version = package_metadata.get("version") if isinstance(package_metadata, dict) else None
-    minimum_hermes = inline_metadata.get("minHermesVersion") if isinstance(inline_metadata, dict) else None
-    try:
-        from hermes_cli import __version__ as current_hermes
-    except Exception:
-        current_hermes = None
-    current_core = _semver_core(current_hermes)
-    minimum_core = _semver_core(minimum_hermes)
-    if not candidate_version or not current_core or not minimum_core:
-        _log_inline_update_failure(
-            "precheck",
-            f"invalid compatibility metadata for {package_spec}; current Hermes version={current_hermes!r}",
-            output=precheck.stdout,
-            hermes_home=hermes_home,
-        )
-        return (
-            "Inline plugin compatibility metadata could not be verified; "
-            "no update was applied. Details were written to Hermes logs under `[inline-update]`."
-        )
-    if current_core < minimum_core:
-        return (
-            f"Inline plugin `{candidate_version}` requires Hermes `{minimum_hermes}` or newer, "
-            f"but this agent is running `{current_hermes}`. Update Hermes first; no plugin update was applied."
-        )
-
-    command = [
-        npm_bin,
-        "exec",
-        "--yes",
-        f"--package={package_spec}",
-        "--",
-        "inline-hermes",
-        "install",
-        "--force",
-        "--hermes-home",
-        str(hermes_home),
-    ]
-    try:
-        result = subprocess.run(
-            command,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            text=True,
-            timeout=_INLINE_UPDATE_TIMEOUT_SECONDS,
-            check=False,
-            env=_inline_update_environment(),
-        )
-    except subprocess.TimeoutExpired as exc:
-        _log_inline_update_failure(
-            "install",
-            f"npm exec timed out for {package_spec}",
-            output=exc.stdout,
-            hermes_home=hermes_home,
-        )
-        return (
-            "Inline plugin update timed out. Run "
-            f"`npm exec --yes --package={package_spec} -- "
-            "inline-hermes install --force` on the Hermes host. Details were written to Hermes logs under `[inline-update]`."
-        )
-    except OSError as exc:
-        _log_inline_update_failure("install", f"npm exec could not start: {exc}", hermes_home=hermes_home)
-        return "Inline plugin update could not start. Check that npm is installed and usable on the Hermes host. Details were written to Hermes logs under `[inline-update]`."
-
-    if result.returncode != 0:
-        _log_inline_update_failure(
-            "install",
-            f"npm exec exited with code {result.returncode} for {package_spec}",
-            output=result.stdout,
-            hermes_home=hermes_home,
-        )
-        return (
-            f"Inline plugin update failed with exit code {result.returncode}. Run "
-            f"`npm exec --yes --package={package_spec} -- "
-            "inline-hermes install --force` on the Hermes host. Details were written to Hermes logs under `[inline-update]`."
-        )
-
-    version = _installed_inline_plugin_version(hermes_home)
-    version_text = f" to `{version}`" if version else ""
-    return f"Inline plugin updated{version_text} from the `{lane}` channel. Run `/restart` to load the new version."
-
-
-async def _inline_update_command_handler(raw_args: str = "") -> str:
-    if str(raw_args or "").strip():
-        return "Usage: `/inline_update`"
-    return await asyncio.to_thread(_run_inline_update)
-
-
 async def _inline_sync_command_handler(raw_args: str = "") -> str:
     if str(raw_args or "").strip():
         return "Usage: `/inline_sync`"
@@ -5641,11 +5392,6 @@ def _inline_command_specs() -> tuple[_InlineCommandSpec, ...]:
             handler=_inline_unfollow_command_handler,
             description=_INLINE_UNFOLLOW_COMMAND_DESCRIPTION,
         ),
-        _InlineCommandSpec(
-            name="inline-update",
-            handler=_inline_update_command_handler,
-            description=_INLINE_UPDATE_COMMAND_DESCRIPTION,
-        ),
         _InlineCommandSpec(
             name="inline-sync",
             handler=_inline_sync_command_handler,

package/plugin/inline/cli.py

@@ -27,7 +27,7 @@ _CLI_INSTALL_URL = "https://inline.chat/cli/install.sh"
 _MAX_TOKEN_BYTES = 16 * 1024
 _MAX_PROBE_RESPONSE_BYTES = 64 * 1024
 _MACHINE_SETUP_PROTOCOL_VERSION = 1
-_PROBE_USER_AGENT = "inline-hermes-agent-adapter/0.0.18-alpha.0"
+_PROBE_USER_AGENT = "inline-hermes-agent-adapter/0.0.19"
 _ENV_REFERENCE_RE = re.compile(r"^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$")
 
 
@@ -362,6 +362,7 @@ def register_cli(parser: argparse.ArgumentParser) -> None:
     setup.add_argument("--json", action="store_true", help="Print compact machine-readable setup output.")
     status = subs.add_parser("status", help="Show Inline adapter status", description="Check Inline configuration, sidecar, Node runtime, and optional credential identity.")
     status.add_argument("--json", action="store_true", help="Print compact machine-readable status output.")
+    status.add_argument("--check-compatibility", action="store_true", help="Validate the installed plugin with the Hermes loader.")
     status.add_argument("--probe", action="store_true", help="Verify the configured Inline credential and bot identity.")
     parser.set_defaults(func=dispatch)
 
@@ -453,7 +454,9 @@ def _status(args) -> int:
         and sidecar["size"] > 0
     )
     runtime_usable = bool(sidecar["ok"] and node["ok"])
-    ready = runtime_usable and configured and (not probe_requested or bool(probe and probe.get("ok")))
+    compatibility = _compatibility_status() if getattr(args, "check_compatibility", False) else None
+    compatible = compatibility is None or compatibility["ok"]
+    ready = compatible and runtime_usable and configured and (not probe_requested or bool(probe and probe.get("ok")))
     result = {
         "ok": ready,
         "ready": ready,
@@ -467,11 +470,14 @@ def _status(args) -> int:
         "node": node,
         "probeRequested": probe_requested,
         "gateway": _gateway_status(),
+        **({"compatibility": compatibility} if compatibility is not None else {}),
         **({"probe": probe} if probe is not None else {}),
     }
     if getattr(args, "json", False):
         print(json.dumps(result, separators=(",", ":")))
     else:
+        if compatibility is not None:
+            print(f"Hermes plugin compatible: {'yes' if compatibility['ok'] else 'no'} ({compatibility['reason']})")
         print(f"Inline configured: {'yes' if configured else 'no'}")
         print(f"Inline sidecar usable: {'yes' if sidecar['ok'] else 'no'}")
         print(f"Node available: {_node_status_text(node)}")
@@ -481,7 +487,46 @@ def _status(args) -> int:
         elif probe_requested:
             print(f"Inline credential probe: {'ready' if ready else 'failed'}")
         print("Advanced diagnostics: inline-hermes doctor --json")
-    return 0 if runtime_usable and (not probe_requested or ready) else 1
+    return 0 if compatible and runtime_usable and (not probe_requested or ready) else 1
+
+
+def _compatibility_status() -> dict:
+    """Attest only a successful host load of this exact installed plugin.
+
+    Never return host exception text: configuration or import errors may contain
+    credentials. A missing diagnostic API is an inconclusive check, not success.
+    """
+    unavailable = {"ok": False, "reason": "loader_unavailable"}
+    try:
+        from hermes_cli.plugins import get_plugin_manager
+
+        manager = get_plugin_manager()
+        manager.discover_and_load()
+        plugin_dir = Path(__file__).resolve().parent
+        loaded = next((
+            item for item in manager._plugins.values()
+            if item.manifest.name == "inline-platform"
+            and Path(item.manifest.path).resolve() == plugin_dir
+        ), None)
+        if loaded is None:
+            return {"ok": False, "reason": "plugin_not_loaded"}
+        if not loaded.enabled or loaded.error or loaded.module is None:
+            return {"ok": False, "reason": "plugin_load_failed"}
+        if "inline" not in loaded.tools_registered:
+            return {"ok": False, "reason": "tool_not_registered"}
+        # Older supported Hermes releases predate the moved-import scanner.
+        # Their loader still checks real imports and plugin registration above.
+        try:
+            from hermes_cli.plugin_compat import plugin_hits
+        except ModuleNotFoundError as error:
+            if error.name != "hermes_cli.plugin_compat":
+                raise
+        else:
+            if plugin_hits(loaded.manifest):
+                return {"ok": False, "reason": "deprecated_imports"}
+        return {"ok": True, "reason": "loaded", "pluginPath": str(plugin_dir)}
+    except Exception:
+        return unavailable
 
 
 def _gateway_status() -> dict:

package/plugin/inline/plugin.yaml

@@ -1,7 +1,10 @@
 name: inline-platform
 label: Inline
 kind: platform
-version: 0.0.18-alpha.0
+provides_tools:
+  - inline
+version: 0.0.19
+requires_hermes: ">=0.21.4"
 description: >
   Inline platform adapter for Hermes Agent. The adapter runs as a native
   Hermes Python platform plugin and supervises a local Node sidecar that uses