@inline-chat/hermes-agent-adapter 0.0.22 → 1.0.0-alpha.2

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.22"
+_PROBE_USER_AGENT = "inline-hermes-agent-adapter/1.0.0-alpha.2"
 _ENV_REFERENCE_RE = re.compile(r"^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$")
 
 
@@ -457,6 +457,10 @@ def _status(args) -> int:
     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")))
+    gateway = _gateway_status()
+    receiving = _receiving_status(
+        configured=configured, runtime_usable=runtime_usable, compatible=compatible, probe=probe, gateway=gateway,
+    )
     result = {
         "ok": ready,
         "ready": ready,
@@ -469,7 +473,8 @@ def _status(args) -> int:
         "sidecar": sidecar,
         "node": node,
         "probeRequested": probe_requested,
-        "gateway": _gateway_status(),
+        "gateway": gateway,
+        "receiving": receiving,
         **({"compatibility": compatibility} if compatibility is not None else {}),
         **({"probe": probe} if probe is not None else {}),
     }
@@ -482,6 +487,10 @@ def _status(args) -> int:
         print(f"Inline sidecar usable: {'yes' if sidecar['ok'] else 'no'}")
         print(f"Node available: {_node_status_text(node)}")
         print(f"Inline runtime ready: {'yes' if ready else 'no'}")
+        # "Ready" means installed and configured; this says whether messages arrive now.
+        print(f"Receiving Inline messages: {'yes' if receiving['ok'] else 'no'}")
+        if not receiving["ok"] and configured and receiving["next"]:
+            print(f"Next: {receiving['next']}")
         if not configured:
             print("Next: run `hermes inline setup` for guided bot setup.")
         elif probe_requested:
@@ -538,10 +547,19 @@ def _gateway_status() -> dict:
         from gateway.status import read_runtime_status, get_runtime_status_running_pid
         from hermes_constants import get_hermes_home
 
-        runtime = read_runtime_status()
-        # Also validate this helper contract for an absent runtime: older hosts
-        # lack expected_home and must not claim support until after installation.
-        pid = get_runtime_status_running_pid(runtime if isinstance(runtime, dict) else {}, expected_home=get_hermes_home())
+        home = get_hermes_home()
+        platform_keys = ["inline"]
+        served = _multiplexed_gateway_for(home)
+        if served is not None:
+            # Hermes 0.22+: one gateway serves every profile from the launch profile's
+            # status file, keyed <profile>:inline.
+            pid, runtime, profile_key = served
+            platform_keys = [profile_key, "inline"]
+        else:
+            runtime = read_runtime_status()
+            # Also validate this helper contract for an absent runtime: older hosts
+            # lack expected_home and must not claim support until after installation.
+            pid = get_runtime_status_running_pid(runtime if isinstance(runtime, dict) else {}, expected_home=home)
         if not isinstance(runtime, dict):
             return {"supported": True, "ready": False, "reason": "missing_status"}
         # Return only an opaque generation, never process IDs or raw state.
@@ -552,7 +570,10 @@ def _gateway_status() -> dict:
         generation = hashlib.sha256(f"inline-gateway:{pid}:{start_time}".encode()).hexdigest() if valid_identity else None
         state = runtime.get("gateway_state")
         platforms = runtime.get("platforms")
-        inline = platforms.get("inline") if isinstance(platforms, dict) else None
+        inline = next(
+            (platforms[key] for key in platform_keys if isinstance(platforms, dict) and isinstance(platforms.get(key), dict)),
+            None,
+        )
         platform_state = inline.get("state") if isinstance(inline, dict) else None
         state = state if state in ("starting", "running", "draining", "stopping", "stopped", "startup_failed") else "unknown"
         platform_state = platform_state if platform_state in ("connected", "connecting", "retrying", "fatal", "disconnected") else "unknown"
@@ -576,6 +597,51 @@ def _gateway_status() -> dict:
         return unavailable
 
 
+def _multiplexed_gateway_for(home) -> "tuple[int, dict, str] | None":
+    """The live multiplexed gateway serving this profile, as (pid, status, platform key)."""
+    try:
+        from gateway.status import multiplexer_liveness_for_profile, profile_name_for_home
+    except ImportError:
+        return None
+    try:
+        served = multiplexer_liveness_for_profile(Path(home))
+        name = profile_name_for_home(Path(home))
+    except Exception:
+        return None
+    if not served or not name:
+        return None
+    pid, runtime = served
+    return pid, runtime, f"{name}:inline"
+
+
+def _receiving_status(*, configured: bool, runtime_usable: bool, compatible: bool, probe: "dict | None", gateway: dict) -> dict:
+    """Whether Inline messages can reach this agent right now, with the first thing to fix.
+
+    Separate from ``ready``, which keeps meaning "installed and configured" for setup.
+    """
+    if not compatible:
+        return {"ok": False, "reason": "incompatible_host", "next": "Update Hermes or the Inline adapter to a supported pair."}
+    if not configured:
+        return {"ok": False, "reason": "not_configured", "next": "Run `hermes inline setup`."}
+    if not runtime_usable:
+        return {"ok": False, "reason": "runtime_unusable", "next": "Run `inline-hermes doctor --json` for the Node or sidecar problem."}
+    if probe is not None and not probe.get("ok"):
+        return {"ok": False, "reason": "credential_rejected", "next": "Check the Inline bot token."}
+    if not gateway.get("supported"):
+        return {"ok": False, "reason": "gateway_unknown", "next": "This Hermes can't report gateway state; check `hermes gateway status`."}
+    if not gateway.get("ready"):
+        reason = str(gateway.get("reason") or "gateway_not_ready")
+        hint = {
+            "missing_status": "Start the gateway: `hermes gateway start`.",
+            "stale_pid": "Start the gateway: `hermes gateway start`.",
+            "gateway_not_running": "Start the gateway: `hermes gateway start`.",
+            "platform_status_stale": "Restart the gateway: `hermes gateway restart`.",
+            "platform_not_connected": "The gateway runs but Inline isn't connected; check `hermes gateway status` and its logs.",
+        }.get(reason, "Check `hermes gateway status`.")
+        return {"ok": False, "reason": reason, "next": hint}
+    return {"ok": True, "reason": "connected", "next": None}
+
+
 def _plugin_version() -> str:
     """Read the separately installed plugin version without package-manager state."""
     try:

package/plugin/inline/plugin.yaml

@@ -3,7 +3,7 @@ label: Inline
 kind: platform
 provides_tools:
   - inline
-version: 0.0.22
+version: 1.0.0-alpha.2
 requires_hermes: ">=0.21.3"
 description: >
   Inline platform adapter for Hermes Agent. The adapter runs as a native
@@ -66,11 +66,11 @@ optional_env:
     prompt: "Allowed group sender ids"
     password: false
   - name: INLINE_REQUIRE_MENTION
-    description: "Require a mention/wake word in group chats. Replies to the bot and dialogs already marked FOLLOWING can continue without one unless strict mention is enabled (default true)."
+    description: "Require an @mention in group chats. Replies to the bot and dialogs already marked FOLLOWING can continue without one unless strict mention is enabled (default true)."
     prompt: "Require group mention? (true/false)"
     password: false
   - name: INLINE_STRICT_MENTION
-    description: "Require an explicit mention/wake word on every group-chat turn, including replies to the bot and followed threads (true/false, default false)"
+    description: "Require an explicit @mention on every group-chat turn, including replies to the bot and followed threads (true/false, default false)"
     prompt: "Require every group turn to mention Hermes? (true/false)"
     password: false
   - name: INLINE_ALLOWED_CHATS
@@ -82,8 +82,8 @@ optional_env:
     prompt: "Free-response Inline chat ids"
     password: false
   - name: INLINE_REPLY_THREADS
-    description: "Reply-thread mode: auto, on, or off. Auto creates child reply threads only for explicit thread requests (default auto)."
-    prompt: "Reply-thread mode (auto/on/off)"
+    description: "Retired: replies stay in the chat unless someone asks for a thread. Turn reply threads on per chat with /threads on."
+    prompt: "Reply-thread mode (retired; leave empty)"
     password: false
   - name: INLINE_CONTEXT_BACKFILL
     description: "Automatic context mode: selective, off, or always (default selective)"
@@ -117,10 +117,6 @@ optional_env:
     description: "Show processing reactions on handled inbound messages: eyes while working, then success or failure (true/false, default false)"
     prompt: "Show processing reactions? (true/false)"
     password: false
-  - name: INLINE_MENTION_PATTERNS
-    description: "Mention wake-word regexes, JSON list or comma/newline-separated"
-    prompt: "Mention patterns"
-    password: false
   - name: INLINE_HOME_CHANNEL
     description: "Default target for cron/standalone sends, for example chat:123"
     prompt: "Home Inline target"
@@ -130,7 +126,7 @@ optional_env:
     prompt: "Home target display name"
     password: false
   - name: INLINE_SIDECAR_PORT
-    description: "Loopback port for the Node sidecar, 1-65535 (default 8794)"
+    description: "Loopback port for the Node sidecar, 1-65535 (default: a free port; 8794 with autostart off)"
     prompt: "Sidecar port"
     password: false
   - name: INLINE_SIDECAR_BIND

package/plugin/inline/profile.py

@@ -0,0 +1,86 @@
+"""Per-profile settings and state for the Inline platform.
+
+Since Hermes 0.22 one gateway process can serve every profile. Credentials and
+settings then come from the routed profile's scope rather than ``os.environ``,
+and anything written to disk has to be owned by one profile and one bot.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+from pathlib import Path
+from typing import Optional
+
+
+def inline_env(name: str, default: Optional[str] = None) -> Optional[str]:
+    """Read an INLINE_* setting from the active profile, falling back to the process env on older hosts."""
+    try:
+        from agent.secret_scope import get_secret
+    except ImportError:
+        return os.getenv(name, default)
+    try:
+        return get_secret(name, default)
+    except Exception as exc:
+        # A multiplexed host with no profile scope fails closed rather than
+        # handing out another profile's value.
+        if type(exc).__name__ == "UnscopedSecretError":
+            return default
+        raise
+
+
+def hermes_home() -> Path:
+    """The Hermes home of the profile this code is running for."""
+    try:
+        from hermes_constants import get_hermes_home
+
+        return Path(get_hermes_home())
+    except Exception:
+        return Path(os.getenv("HERMES_HOME") or Path.home() / ".hermes").expanduser()
+
+
+def legacy_state_dir() -> Path:
+    """Where releases before the profile split kept state, whatever the profile."""
+    return Path.home() / ".hermes" / "inline"
+
+
+def state_dir() -> Path:
+    return hermes_home() / "inline"
+
+
+def bot_state_key(base_url: str, token: str) -> str:
+    """A stable, non-secret name for one bot on one API.
+
+    Inline bot tokens start with the bot's user id, so the name survives token
+    rotation; anything else falls back to a hash of the token.
+    """
+    server = hashlib.sha256(base_url.encode("utf-8")).hexdigest()[:8]
+    bot_id, separator, _ = token.partition(":")
+    if separator and bot_id.isdigit():
+        return f"bot{bot_id}-{server}"
+    return hashlib.sha256(f"{base_url}\n{token}".encode("utf-8")).hexdigest()[:16]
+
+
+def multiplex_active() -> bool:
+    """Whether this process serves several Hermes profiles (Hermes 0.22+)."""
+    try:
+        from agent.secret_scope import is_multiplex_active
+    except ImportError:
+        return False
+    try:
+        return bool(is_multiplex_active())
+    except Exception:
+        return False
+
+
+def may_adopt_legacy_state() -> bool:
+    """Whether the pre-split shared state file can be trusted as this adapter's own.
+
+    The legacy file never recorded which bot wrote it. Only the classic install,
+    the default profile in a gateway serving just that profile, plausibly owns it.
+    Everyone else, including every profile of a multiplexed gateway, starts from
+    now: that can miss messages sent while the gateway was down, but never replays
+    answered ones. The old file stays in place for recovery.
+    """
+    default_root = (Path.home() / ".hermes").resolve()
+    return hermes_home().resolve() == default_root and not multiplex_active()