@inline-chat/hermes-agent-adapter 0.0.4 → 0.0.5-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inline-chat/hermes-agent-adapter",
-  "version": "0.0.4",
+  "version": "0.0.5-alpha.1",
   "description": "Hermes Agent platform adapter for Inline, with a native Python plugin and bundled Inline realtime sidecar.",
   "license": "Apache-2.0",
   "type": "module",
@@ -49,11 +49,12 @@
   },
   "scripts": {
     "build": "mkdir -p plugin/inline/sidecar && bun build ./src/install.ts --outdir dist --entry-naming '[name].js' --target=node --format=esm --packages=bundle && bun build ./src/sidecar/index.ts --outdir plugin/inline/sidecar --entry-naming 'index.mjs' --target=node --format=esm --packages=bundle && tsc -p tsconfig.json --emitDeclarationOnly",
-    "lint": "bunx oxlint --ignore-path ../.oxlintignore src/install.ts src/sidecar/contract.ts src/sidecar/index.ts tests/adapter-python.test.ts tests/install.test.ts tests/package-artifact.test.ts tests/sidecar-contract.test.ts tests/sidecar-runtime.test.ts vitest.config.ts",
-    "pretest": "bun run build && rm -rf coverage",
+    "lint": "bunx oxlint --ignore-path ../.oxlintignore scripts/release-stage.mjs src/install.ts src/sidecar/contract.ts src/sidecar/index.ts tests/adapter-python.test.ts tests/install.test.ts tests/package-artifact.test.ts tests/sidecar-contract.test.ts tests/sidecar-runtime.test.ts vitest.config.ts",
+    "pretest": "bun run build",
     "prepack": "bun run build",
     "prepublishOnly": "bun run check",
-    "release:preflight": "npm publish --dry-run --access public",
+    "release:preflight": "node ./scripts/release-stage.mjs --dry-run",
+    "release:stage": "node ./scripts/release-stage.mjs --prepare-only",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "vitest run --coverage",
     "check": "bun run typecheck && bun run lint && bun run test"
@@ -63,10 +64,10 @@
     "yaml": "2.9.0"
   },
   "devDependencies": {
-    "@types/node": "20.17.19",
-    "@vitest/coverage-v8": "4.0.16",
+    "@types/node": "20.19.43",
+    "@vitest/coverage-v8": "4.1.10",
     "typescript": "5.8.3",
-    "vitest": "4.0.16"
+    "vitest": "4.1.10"
   },
   "publishConfig": {
     "access": "public"
@@ -75,7 +76,7 @@
     "pluginId": "inline",
     "pluginPath": "plugin/inline",
     "minHermesVersion": "0.17.0",
-    "testedHermesVersion": "0.17.0",
-    "testedHermesCommit": "824f2279"
+    "testedHermesVersion": "0.18.2",
+    "testedHermesCommit": "9de9c25"
   }
 }

package/plugin/inline/adapter.py

@@ -17,6 +17,7 @@ import re
 import secrets
 import shutil
 import signal
+import socket
 import subprocess
 import sys
 import time
@@ -78,7 +79,6 @@ _INLINE_COMMAND_LIMIT = 100
 _INLINE_COMMAND_DESCRIPTION_LIMIT = 256
 _INLINE_COMMAND_RETRY_RATIO = 0.8
 _INLINE_COMMAND_RE = re.compile(r"^[a-z0-9_]{1,32}$")
-_REPLY_THREAD_AUTO_CREATE_MIN_MESSAGES = 50
 _INLINE_THREADS_COMMAND_DESCRIPTION = "Configure Inline reply-thread routing"
 _INLINE_THREADS_COMMAND_ARGS = "[status|on|off|auto|reset]"
 _INLINE_THREADS_ACTION_PREFIX = "th:"
@@ -213,6 +213,14 @@ def _normalize_sidecar_port(value: Any) -> int:
     return port
 
 
+def _available_loopback_port(bind: str) -> int:
+    """Choose an unused loopback port for a short-lived standalone sidecar."""
+    family = socket.AF_INET6 if ":" in bind else socket.AF_INET
+    with socket.socket(family, socket.SOCK_STREAM) as sock:
+        sock.bind((bind, 0))
+        return int(sock.getsockname()[1])
+
+
 def _normalize_positive_float(value: Any, default: float, name: str) -> float:
     if value is None or str(value).strip() == "":
         return default
@@ -584,15 +592,19 @@ class InlineAdapter(BasePlatformAdapter):
     supports_code_blocks = True
     splits_long_messages = True
 
-    def __init__(self, config: PlatformConfig):
+    def __init__(self, config: PlatformConfig, *, use_ephemeral_sidecar_port: bool = False):
         super().__init__(config, Platform("inline"))
         extra = config.extra or {}
 
         self._token = _config_token(config)
         self._base_url = os.getenv("INLINE_BASE_URL") or extra.get("base_url") or "https://api.inline.chat"
-        sidecar_port = extra.get("sidecar_port") if "sidecar_port" in extra else os.getenv("INLINE_SIDECAR_PORT")
-        self._sidecar_port = _normalize_sidecar_port(sidecar_port)
         self._sidecar_bind = _normalize_sidecar_bind(extra.get("sidecar_bind") or os.getenv("INLINE_SIDECAR_BIND"))
+        sidecar_port = extra.get("sidecar_port") if "sidecar_port" in extra else os.getenv("INLINE_SIDECAR_PORT")
+        self._sidecar_port = (
+            _available_loopback_port(self._sidecar_bind)
+            if use_ephemeral_sidecar_port
+            else _normalize_sidecar_port(sidecar_port)
+        )
         self._connect_timeout_ms = _normalize_positive_float(
             extra.get("connect_timeout_ms") if "connect_timeout_ms" in extra else os.getenv("INLINE_CONNECT_TIMEOUT_MS"),
             _DEFAULT_CONNECT_TIMEOUT_MS,
@@ -860,16 +872,6 @@ class InlineAdapter(BasePlatformAdapter):
             self._reply_thread_overrides[key] = _reply_thread_mode(value, "auto")
         self._save_reply_thread_overrides()
 
-    @staticmethod
-    def _positive_int(value: Any) -> Optional[int]:
-        text = str(value or "").strip()
-        if not re.fullmatch(r"[1-9]\d*", text):
-            return None
-        try:
-            return int(text)
-        except ValueError:
-            return None
-
     @staticmethod
     def _has_reply_thread_intent(text: str) -> bool:
         normalized = re.sub(r"\s+", " ", str(text or "").strip())
@@ -884,7 +886,6 @@ class InlineAdapter(BasePlatformAdapter):
         *,
         chat_id: str,
         parent_chat_id: Optional[str],
-        msg_id: str,
         text: str,
     ) -> bool:
         mode = self._reply_thread_mode_for_chat(chat_id, parent_chat_id)
@@ -894,8 +895,7 @@ class InlineAdapter(BasePlatformAdapter):
             return True
         if self._has_reply_thread_intent(text):
             return True
-        message_id = self._positive_int(msg_id)
-        return message_id is not None and message_id >= _REPLY_THREAD_AUTO_CREATE_MIN_MESSAGES
+        return False
 
     @staticmethod
     def _id_allowed(entries: set[str], value: str) -> bool:
@@ -978,10 +978,7 @@ class InlineAdapter(BasePlatformAdapter):
         if mode == "on":
             behavior = "Top-level replies will start or reuse Inline reply threads."
         elif mode == "auto":
-            behavior = (
-                "Top-level replies stay in the parent chat until "
-                f"message #{_REPLY_THREAD_AUTO_CREATE_MIN_MESSAGES} or an explicit thread request."
-            )
+            behavior = "Top-level replies stay in the parent chat unless a thread is explicitly requested."
         else:
             behavior = "Top-level replies stay in the parent chat."
         first_line = f"Inline reply threads are {mode} for this chat ({scope})."
@@ -1516,7 +1513,6 @@ class InlineAdapter(BasePlatformAdapter):
             and self._should_create_reply_thread_for_message(
                 chat_id=chat_id,
                 parent_chat_id=parent_chat_id,
-                msg_id=msg_id,
                 text=text,
             )
         ):
@@ -3568,7 +3564,9 @@ async def _standalone_send(pconfig: PlatformConfig, chat_id: str, message: str,
     token = _config_token(pconfig)
     if not token:
         return {"error": "Inline token is required in INLINE_TOKEN, INLINE_BOT_TOKEN, or Hermes Inline config"}
-    adapter = InlineAdapter(pconfig)
+    # The supervised gateway may already own the configured sidecar port. A
+    # one-shot sender launches its own sidecar, so isolate it on a free port.
+    adapter = InlineAdapter(pconfig, use_ephemeral_sidecar_port=True)
     ok = await adapter.connect()
     if not ok:
         return {"error": "failed to connect Inline adapter"}

package/plugin/inline/cli.py

@@ -7,33 +7,296 @@ the plugin has already been discovered by Hermes.
 from __future__ import annotations
 
 import argparse
+import json
 import os
 import re
 import shutil
 import subprocess
+import sys
 
 from pathlib import Path
 
 _SIDECAR_ENTRY = Path(__file__).parent / "sidecar" / "index.mjs"
 _MIN_NODE_MAJOR = 20
+_BOT_USERNAME_RE = re.compile(r"^[A-Za-z0-9_]+bot$", re.IGNORECASE)
+_CLI_INSTALL_URL = "https://inline.chat/cli/install.sh"
 
 
 def gateway_setup() -> None:
-    if _env_token_configured():
-        print("Inline env token configured from INLINE_TOKEN/INLINE_BOT_TOKEN.")
+    """Interactively create or connect an Inline bot.
+
+    Hermes invokes this from its messaging-platform wizard. Keep credential
+    persistence inside Hermes' own config helper so profiles and file
+    permissions behave exactly like the built-in Telegram setup.
+    """
+    from hermes_cli import gateway as hermes_gateway
+    from hermes_cli import setup as hermes_setup
+
+    hermes_setup.print_header("Inline")
+    existing = (
+        hermes_gateway.get_env_value("INLINE_TOKEN")
+        or hermes_gateway.get_env_value("INLINE_BOT_TOKEN")
+    )
+    if existing:
+        hermes_setup.print_info("Inline is already configured.")
+        if not hermes_setup.prompt_yes_no("Reconfigure Inline?", False):
+            return
+
+    hermes_setup.print_info("How would you like to connect Hermes to Inline?")
+    print()
+    hermes_setup.print_info("  [1] Create a bot in Inline and paste its token")
+    hermes_setup.print_info("      Go to Settings → Bots → Create a new bot.")
+    hermes_setup.print_info("      https://inline.chat/docs/creating-a-bot")
+    print()
+    hermes_setup.print_info("  [2] Create a bot with the Inline CLI")
+    hermes_setup.print_info("      Install or sign in to the CLI, then create the bot here.")
+    print()
+
+    choice = hermes_setup.prompt("Choice [1/2]", default="1").strip()
+    owner_user_id: str | None = None
+    token: str | None = None
+    if choice == "2":
+        token, owner_user_id = _create_bot_with_inline_cli(hermes_setup)
+        if not token:
+            print()
+            hermes_setup.print_info("Falling back to an existing bot token...")
+
+    if not token:
+        token = _prompt_existing_token(hermes_setup)
+    if not token:
+        hermes_setup.print_warning("No token saved. Inline setup was cancelled.")
+        return
+
+    hermes_gateway.save_env_value("INLINE_TOKEN", token)
+    hermes_setup.print_success("Inline bot token saved securely by Hermes.")
+
+    if not owner_user_id:
+        owner_user_id = _inline_cli_user_id(shutil.which("inline"))
+    _configure_access(hermes_gateway, hermes_setup, owner_user_id)
+
+    print()
+    hermes_setup.print_success("💬 Inline is configured!")
+    hermes_setup.print_info("Restart the gateway when prompted, then message your bot in Inline.")
+    hermes_setup.print_info("Send /sethome in that chat to use it for cron results and notifications.")
+
+
+def _create_bot_with_inline_cli(hermes_setup) -> tuple[str | None, str | None]:
+    inline_bin = _find_inline_cli()
+    if not inline_bin:
+        inline_bin = _install_inline_cli(hermes_setup)
+        if not inline_bin:
+            hermes_setup.print_warning("Automatic bot creation is unavailable because the Inline CLI could not be installed.")
+            hermes_setup.print_info("Install it from https://inline.chat/docs/cli, or use an existing bot token.")
+            return None, None
+
+    owner_user_id = _inline_cli_user_id(inline_bin)
+    if not owner_user_id:
+        print()
+        hermes_setup.print_info("Sign in to Inline to create your Hermes bot.")
+        if not hermes_setup.prompt_yes_no("Sign in now?", True):
+            return None, None
+        login = subprocess.run([inline_bin, "auth", "login"], check=False)
+        if login.returncode != 0:
+            hermes_setup.print_warning("Inline sign-in did not finish successfully.")
+            return None, None
+        owner_user_id = _inline_cli_user_id(inline_bin)
+        if not owner_user_id:
+            hermes_setup.print_warning("Inline sign-in could not be verified.")
+            return None, None
+
+    print()
+    name = hermes_setup.prompt("Bot name", default="Hermes").strip()
+    if not name:
+        return None, owner_user_id
+
+    while True:
+        username = hermes_setup.prompt("Bot username (must end in bot)", default="hermesbot").strip().lstrip("@")
+        if not _BOT_USERNAME_RE.fullmatch(username):
+            hermes_setup.print_warning("Use letters, numbers, or underscores, and end the username with 'bot'.")
+            continue
+
+        payload, error = _run_inline_json(
+            inline_bin,
+            ["bots", "create", "--name", name, "--username", username],
+        )
+        token = str((payload or {}).get("token") or "").strip()
+        if token:
+            bot = (payload or {}).get("bot")
+            bot_name = bot.get("name") if isinstance(bot, dict) else None
+            hermes_setup.print_success(f"Created {bot_name or name} in Inline.")
+            return token, owner_user_id
+
+        hermes_setup.print_warning(error or "Inline could not create the bot.")
+        if not hermes_setup.prompt_yes_no("Try a different username?", True):
+            return None, owner_user_id
+
+
+def _install_inline_cli(hermes_setup) -> str | None:
+    print()
+    hermes_setup.print_info("The Inline CLI is needed to create your bot automatically.")
+    if not hermes_setup.prompt_yes_no("Install the Inline CLI now?", True):
+        hermes_setup.print_info("Inline CLI installation skipped.")
+        return None
+
+    brew_bin = shutil.which("brew") if sys.platform == "darwin" else None
+    if brew_bin:
+        hermes_setup.print_info("Installing the Inline CLI with Homebrew...")
+        result = subprocess.run(
+            [brew_bin, "install", "--cask", "inline"],
+            check=False,
+        )
+    else:
+        curl_bin = shutil.which("curl")
+        shell_bin = shutil.which("sh") or "/bin/sh"
+        if not curl_bin:
+            hermes_setup.print_warning("Automatic installation requires curl.")
+            return None
+        hermes_setup.print_info("Downloading the official Inline CLI installer...")
+        try:
+            download = subprocess.run(
+                [curl_bin, "-fsSL", _CLI_INSTALL_URL],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                timeout=60,
+                check=False,
+            )
+        except (OSError, subprocess.TimeoutExpired) as exc:
+            hermes_setup.print_warning(f"Could not download the Inline CLI installer: {exc}")
+            return None
+        if download.returncode != 0 or not download.stdout:
+            hermes_setup.print_warning("Could not download the Inline CLI installer.")
+            return None
+        try:
+            result = subprocess.run(
+                [shell_bin, "-s"],
+                input=download.stdout,
+                timeout=180,
+                check=False,
+            )
+        except (OSError, subprocess.TimeoutExpired) as exc:
+            hermes_setup.print_warning(f"Inline CLI installation failed: {exc}")
+            return None
+
+    if result.returncode != 0:
+        hermes_setup.print_warning("The Inline CLI installer exited unsuccessfully.")
+        return None
+
+    inline_bin = _find_inline_cli()
+    if not inline_bin:
+        hermes_setup.print_warning("The Inline CLI was installed but could not be found on PATH.")
+        return None
+    try:
+        verified = subprocess.run(
+            [inline_bin, "--version"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            timeout=10,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        verified = None
+    if verified is None or verified.returncode != 0:
+        hermes_setup.print_warning("The installed Inline CLI could not be verified.")
+        return None
+
+    hermes_setup.print_success("Inline CLI installed successfully.")
+    return inline_bin
+
+
+def _find_inline_cli() -> str | None:
+    discovered = shutil.which("inline")
+    if discovered:
+        return discovered
+    candidates = [
+        Path("/opt/homebrew/bin/inline"),
+        Path("/usr/local/bin/inline"),
+        Path.home() / ".local" / "bin" / "inline",
+    ]
+    for candidate in candidates:
+        if candidate.is_file() and os.access(candidate, os.X_OK):
+            return str(candidate)
+    return None
+
+
+def _prompt_existing_token(hermes_setup) -> str | None:
+    print()
+    hermes_setup.print_info("Go to Inline → Settings → Bots → Create a new bot, then copy its token.")
+    hermes_setup.print_info("Guide: https://inline.chat/docs/creating-a-bot")
+    token = hermes_setup.prompt("Inline bot token", password=True).strip()
+    return token or None
+
+
+def _configure_access(hermes_gateway, hermes_setup, owner_user_id: str | None) -> None:
+    print()
+    hermes_setup.print_info("🔒 Choose who can talk to Hermes.")
+    allowed: list[str] = []
+    if owner_user_id:
+        hermes_setup.print_success(f"Detected your Inline user ID: {owner_user_id}")
+        if hermes_setup.prompt_yes_no("Allow this Inline account?", True):
+            allowed.append(owner_user_id)
+
+    extra = hermes_setup.prompt("Additional allowed user IDs (comma-separated, optional)").strip()
+    for value in extra.replace(" ", "").split(","):
+        if value and value not in allowed:
+            allowed.append(value)
+
+    if allowed:
+        value = ",".join(allowed)
+        hermes_gateway.save_env_value("INLINE_ALLOW_ALL_USERS", "false")
+        hermes_gateway.save_env_value("INLINE_ALLOWED_USERS", value)
+        hermes_gateway.save_env_value("INLINE_GROUP_ALLOW_FROM", value)
+        hermes_gateway.save_env_value("INLINE_DM_POLICY", "allowlist")
+        hermes_gateway.save_env_value("INLINE_GROUP_POLICY", "allowlist")
+        hermes_setup.print_success("Only the listed Inline users can invoke Hermes.")
+        return
+
+    if hermes_setup.prompt_yes_no("Allow any Inline user who can reach the bot?", False):
+        hermes_gateway.save_env_value("INLINE_ALLOW_ALL_USERS", "true")
+        hermes_gateway.save_env_value("INLINE_DM_POLICY", "open")
+        hermes_gateway.save_env_value("INLINE_GROUP_POLICY", "open")
+        hermes_setup.print_warning("Open access enabled. Any reachable Inline user can invoke Hermes.")
     else:
-        print("Set INLINE_TOKEN or INLINE_BOT_TOKEN in the Hermes gateway environment.")
-        print("Alternatively set platforms.inline.token or inline.token in ~/.hermes/config.yaml.")
-    print("Enable Inline in ~/.hermes/config.yaml:")
-    print("  platforms:")
-    print("    inline:")
-    print("      enabled: true")
-    print("Then run: inline-hermes doctor --json")
+        hermes_gateway.save_env_value("INLINE_ALLOW_ALL_USERS", "false")
+        hermes_gateway.save_env_value("INLINE_DM_POLICY", "disabled")
+        hermes_gateway.save_env_value("INLINE_GROUP_POLICY", "disabled")
+        hermes_setup.print_warning("Messaging is disabled until you add allowed user IDs and re-run setup.")
+
+
+def _inline_cli_user_id(inline_bin: str | None) -> str | None:
+    if not inline_bin:
+        return None
+    payload, _ = _run_inline_json(inline_bin, ["auth", "me"])
+    if not payload:
+        return None
+    raw = payload.get("id")
+    return str(raw).strip() if raw is not None and str(raw).strip() else None
+
+
+def _run_inline_json(inline_bin: str, args: list[str]) -> tuple[dict | None, str | None]:
+    try:
+        result = subprocess.run(
+            [inline_bin, "--json", "--compact", *args],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            timeout=60,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        return None, f"Inline CLI failed: {exc}"
+    if result.returncode != 0:
+        detail = (result.stderr or "").strip().splitlines()
+        return None, detail[-1] if detail else "Inline CLI exited unsuccessfully."
+    try:
+        payload = json.loads(result.stdout)
+    except (json.JSONDecodeError, TypeError):
+        return None, "Inline CLI returned an unreadable response."
+    return payload if isinstance(payload, dict) else None, None
 
 
 def register_cli(parser: argparse.ArgumentParser) -> None:
     subs = parser.add_subparsers(dest="inline_command", required=False)
-    subs.add_parser("setup", help="Show Inline setup instructions")
+    subs.add_parser("setup", help="Configure Inline interactively")
     subs.add_parser("status", help="Show Inline adapter status")
     parser.set_defaults(func=dispatch)
 
@@ -47,13 +310,12 @@ def dispatch(args) -> int:
         return 0
     if command == "status":
         configured = _env_token_configured()
-        print(f"Inline env token configured: {'yes' if configured else 'no'}")
-        print("Hermes config token support: platforms.inline.token or inline.token")
+        print(f"Inline configured: {'yes' if configured else 'no'}")
         print(f"Inline sidecar bundled: {'yes' if _SIDECAR_ENTRY.exists() else 'no'}")
         print(f"Node available: {_node_status()}")
         if not configured:
-            print("Hint: use INLINE_TOKEN/INLINE_BOT_TOKEN for env setup, or platforms.inline.token/inline.token in config.yaml.")
-        print("Install diagnostics: inline-hermes doctor --json")
+            print("Next: run `hermes inline setup` for guided bot setup.")
+        print("Advanced diagnostics: inline-hermes doctor --json")
         return 0
     raise SystemExit(f"unknown inline command: {command}")
 

package/plugin/inline/plugin.yaml

@@ -1,7 +1,7 @@
 name: inline-platform
 label: Inline
 kind: platform
-version: 0.0.4
+version: 0.0.5-alpha.1
 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
@@ -79,7 +79,7 @@ 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 large parent chats or explicit thread requests (default auto)."
+    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)"
     password: false
   - name: INLINE_CONTEXT_BACKFILL