hyperloop 0.8.1__tar.gz → 0.9.1__tar.gz

{hyperloop-0.8.1 → hyperloop-0.9.1}/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 <!-- version list -->
 
+## v0.9.1 (2026-04-15)
+
+### Bug Fixes
+
+- **matrix**: Proper UIA two-step registration flow
+  ([`97080f9`](https://github.com/jsell-rh/hyperloop/commit/97080f9d6980e914451a59d4b2453c7b5294ed30))
+
+
+## v0.9.0 (2026-04-15)
+
+
 ## v0.8.1 (2026-04-15)
 
 ### Bug Fixes

{hyperloop-0.8.1 → hyperloop-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperloop
-Version: 0.8.1
+Version: 0.9.1
 Summary: Orchestrator that walks tasks through composable process pipelines using AI agents
 License-File: LICENSE
 Requires-Python: >=3.12

{hyperloop-0.8.1 → hyperloop-0.9.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hyperloop"
-version = "0.8.1"
+version = "0.9.1"
 description = "Orchestrator that walks tasks through composable process pipelines using AI agents"
 readme = "README.md"
 requires-python = ">=3.12"

{hyperloop-0.8.1 → hyperloop-0.9.1}/src/hyperloop/adapters/matrix_setup.py

@@ -11,18 +11,18 @@ auto-setup and cache.
 from __future__ import annotations
 
 import json
-import logging
 import secrets
 from typing import TYPE_CHECKING, cast
 
 import httpx
+import structlog
 
 if TYPE_CHECKING:
     from pathlib import Path
 
     from hyperloop.config import MatrixConfig
 
-_log = logging.getLogger(__name__)
+_log: structlog.stdlib.BoundLogger = structlog.get_logger()
 
 _CACHE_FILE = ".hyperloop/matrix-state.json"
 
@@ -53,6 +53,8 @@ def _ensure_gitignored(repo_path: Path) -> None:
     """Ensure .hyperloop/ is in the target repo's .gitignore."""
     gitignore = repo_path / ".gitignore"
     entry = ".hyperloop/"
+    if not repo_path.is_dir():
+        return
     if gitignore.is_file():
         content = gitignore.read_text()
         if entry in content.splitlines():
@@ -104,55 +106,52 @@ def _register_bot(
     username: str,
     password: str,
 ) -> tuple[str, str]:
-    """Register a bot user. Returns (user_id, access_token).
+    """Register a bot user via UIA flow. Returns (user_id, access_token).
 
-    Uses Synapse's shared-secret registration flow. If the user already
-    exists (HTTP 400), falls back to login with the given password.
+    Matrix UIA (User-Interactive Authentication) registration:
+    1. POST /register without auth → server returns 401 with session + flows.
+    2. POST /register with auth (type + token + session) → 200 with credentials.
+
+    If the user already exists (HTTP 400), falls back to login.
     """
     url = f"{homeserver}/_matrix/client/v3/register"
-    body = {
+    base_body: dict[str, object] = {
         "username": username,
         "password": password,
-        "auth": {
-            "type": "m.login.registration_token",
-            "token": registration_token,
-        },
         "initial_device_display_name": "hyperloop",
         "inhibit_login": False,
     }
 
-    resp = client.post(url, json=body)
+    # Step 1: request without auth to get session
+    resp = client.post(url, json=base_body)
 
     if resp.status_code == 200:
+        # Some servers accept registration without UIA
         data = resp.json()
         return str(data["user_id"]), str(data["access_token"])
 
-    if resp.status_code == 401:
-        # Server requires a different auth flow — try the flows it offers
-        data = resp.json()
-        flows = data.get("flows", [])
-        session = data.get("session", "")
-
-        # Check if m.login.registration_token is among the available flows
-        for flow in flows:
-            stages = flow.get("stages", [])
-            if "m.login.registration_token" in stages:
-                body["auth"] = {
-                    "type": "m.login.registration_token",
-                    "token": registration_token,
-                    "session": session,
-                }
-                resp = client.post(url, json=body)
-                if resp.status_code == 200:
-                    data = resp.json()
-                    return str(data["user_id"]), str(data["access_token"])
-
     if resp.status_code == 400:
-        # User likely already exists — try login
         return _login(client, homeserver, username, password)
 
+    # Step 2: server should return 401 with session + flows
+    if resp.status_code in (401, 403):
+        data = resp.json()
+        session = data.get("session", "")
+        if session:
+            base_body["auth"] = {
+                "type": "m.login.registration_token",
+                "token": registration_token,
+                "session": session,
+            }
+            resp = client.post(url, json=base_body)
+            if resp.status_code == 200:
+                data = resp.json()
+                return str(data["user_id"]), str(data["access_token"])
+            if resp.status_code == 400:
+                return _login(client, homeserver, username, password)
+
     resp.raise_for_status()
-    msg = f"Unexpected registration response: {resp.status_code}"
+    msg = f"Registration failed: {resp.status_code} {resp.text}"
     raise RuntimeError(msg)
 
 
@@ -182,15 +181,18 @@ def _create_room(
     homeserver: str,
     access_token: str,
     room_name: str,
+    invite_user: str = "",
 ) -> str:
-    """Create a private Matrix room. Returns the room_id."""
+    """Create a private Matrix room and optionally invite a user. Returns the room_id."""
     url = f"{homeserver}/_matrix/client/v3/createRoom"
-    body = {
+    body: dict[str, object] = {
         "name": room_name,
         "topic": "hyperloop orchestrator notifications",
         "visibility": "private",
         "preset": "private_chat",
     }
+    if invite_user:
+        body["invite"] = [invite_user]
 
     resp = client.post(
         url,
@@ -213,15 +215,15 @@ def ensure_matrix_ready(
 ) -> tuple[str, str]:
     """Ensure Matrix credentials and room are available.
 
-    Resolution order for **access_token**:
-    1. Explicit ``token_env`` env var
-    2. Cached token from ``.hyperloop/matrix-state.json``
-    3. Auto-register via ``registration_token_env``
+    **Access token** resolution:
+    1. Explicit ``token_env`` env var → use directly.
+    2. ``registration_token_env`` → register a fresh disposable bot
+       (``hyperloop-{repo}-{random}``), deactivate the previous one.
 
-    Resolution order for **room_id**:
-    1. Explicit ``room_id`` in config
-    2. Cached room_id
-    3. Auto-create via Matrix API
+    **Room ID** resolution:
+    1. Explicit ``room_id`` in config.
+    2. Cached room_id from ``.hyperloop/matrix-state.json``.
+    3. Auto-create via Matrix API (invites ``invite_user``).
 
     Returns:
         (access_token, room_id) tuple. Either or both may be empty string
@@ -234,23 +236,21 @@ def ensure_matrix_ready(
 
     # --- Resolve access token ---
     explicit_token = os.environ.get(config.token_env) if config.token_env else ""
-    cached_token = cache.get("access_token", "") if cache else ""
-    access_token = explicit_token or cached_token
+    access_token = explicit_token
 
     if not access_token:
-        # Try auto-registration
         registration_token = (
             os.environ.get(config.registration_token_env) if config.registration_token_env else ""
         )
         if registration_token:
             try:
-                access_token = _auto_register(
+                access_token = _register_disposable_bot(
                     config, repo_path, homeserver, registration_token, cache
                 )
             except Exception:
-                _log.exception("Matrix bot registration failed")
+                _log.exception("matrix_bot_registration_failed")
         else:
-            _log.warning("Matrix: no access token and no registration token — skipping")
+            _log.warning("matrix_skipped", reason="no access token and no registration token")
             return "", ""
 
     if not access_token:
@@ -261,62 +261,107 @@ def ensure_matrix_ready(
     room_id = config.room_id or cached_room
 
     if not room_id:
+        _log.info("matrix_room_creating")
         try:
             room_id = _auto_create_room(config, repo_path, homeserver, access_token)
         except Exception:
-            _log.exception("Matrix room creation failed")
+            _log.exception("matrix_room_creation_failed")
             return access_token, ""
 
+    # Ensure the bot has joined the room (it's a new user each run)
+    if access_token != explicit_token and room_id:
+        _log.info("matrix_room_joining", room_id=room_id)
+        try:
+            _join_room(httpx.Client(timeout=10.0), homeserver, access_token, room_id)
+        except Exception:
+            _log.exception("matrix_room_join_failed", room_id=room_id)
+
     return access_token, room_id
 
 
-def _auto_register(
+def _register_disposable_bot(
     config: MatrixConfig,
     repo_path: Path,
     homeserver: str,
     registration_token: str,
     cache: dict[str, str] | None,
 ) -> str:
-    """Register a bot user and cache credentials. Returns access_token."""
-    repo_name = repo_path.name
-    username = config.bot_username or f"hyperloop-{repo_name}"
+    """Register a fresh disposable bot user. Returns access_token.
 
-    password = cache.get("password", "") if cache else ""
-    if not password:
-        password = secrets.token_urlsafe(32)
+    Each run gets a new identity (``hyperloop-{repo}-{random}``). The
+    previous bot is deactivated best-effort. Only the room_id is cached.
+    """
+    repo_name = repo_path.name
+    suffix = secrets.token_hex(4)
+    username = f"hyperloop-{repo_name}-{suffix}"
+    password = secrets.token_urlsafe(32)
 
     client = httpx.Client(timeout=30.0)
     try:
+        # Deactivate previous bot (best-effort)
+        prev_token = cache.get("access_token", "") if cache else ""
+        if prev_token:
+            _deactivate_user(client, homeserver, prev_token)
+
+        # Register new bot
         user_id, access_token = _register_bot(
             client, homeserver, registration_token, username, password
         )
 
+        # Cache room_id + new bot credentials
+        cached_room = cache.get("room_id", "") if cache else ""
         _save_cache(
             repo_path,
             homeserver=homeserver,
             user_id=user_id,
             access_token=access_token,
-            room_id=config.room_id,
+            room_id=config.room_id or cached_room,
             password=password,
         )
 
-        _log.info("Matrix bot registered: %s", user_id)
+        _log.info("matrix_bot_registered", user_id=user_id)
         return access_token
     finally:
         client.close()
 
 
+def _deactivate_user(client: httpx.Client, homeserver: str, access_token: str) -> None:
+    """Deactivate the user associated with the given access token. Best-effort."""
+    import contextlib
+
+    url = f"{homeserver}/_matrix/client/v3/account/deactivate"
+    with contextlib.suppress(Exception):
+        client.post(
+            url,
+            json={"auth": {"type": "m.login.password"}},
+            headers={"Authorization": f"Bearer {access_token}"},
+        )
+
+
+def _join_room(client: httpx.Client, homeserver: str, access_token: str, room_id: str) -> None:
+    """Join a room by ID."""
+    url = f"{homeserver}/_matrix/client/v3/join/{room_id}"
+    resp = client.post(url, json={}, headers={"Authorization": f"Bearer {access_token}"})
+    resp.raise_for_status()
+
+
 def _auto_create_room(
     config: MatrixConfig,
     repo_path: Path,
     homeserver: str,
     access_token: str,
 ) -> str:
-    """Create a room and update the cache. Returns room_id."""
+    """Create a room, invite the configured user, and cache room_id. Returns room_id."""
     repo_name = repo_path.name
     client = httpx.Client(timeout=30.0)
     try:
-        room_id = _create_room(client, homeserver, access_token, f"hyperloop-{repo_name}")
+        room_id = _create_room(
+            client,
+            homeserver,
+            access_token,
+            f"hyperloop-{repo_name}",
+            invite_user=config.invite_user,
+        )
 
         # Update cache with the new room_id
         cache = _load_cache(repo_path, homeserver) or {}
@@ -329,7 +374,7 @@ def _auto_create_room(
             password=cache.get("password", ""),
         )
 
-        _log.info("Matrix room created: %s", room_id)
+        _log.info("matrix_room_created", room_id=room_id)
         return room_id
     finally:
         client.close()

{hyperloop-0.8.1 → hyperloop-0.9.1}/src/hyperloop/config.py

@@ -31,7 +31,7 @@ class MatrixConfig:
     token_env: str
     verbose: bool
     registration_token_env: str  # env var holding the registration token
-    bot_username: str
+    invite_user: str  # Matrix user ID to invite to auto-created rooms
 
 
 @dataclass(frozen=True)
@@ -144,7 +144,7 @@ def _flatten_yaml(raw: dict[str, object]) -> dict[str, object]:
             flat["matrix_token_env"] = mx.get("token_env", "")
             flat["matrix_verbose"] = mx.get("verbose", False)
             flat["matrix_registration_token_env"] = mx.get("registration_token_env", "")
-            flat["matrix_bot_username"] = mx.get("bot_username", "")
+            flat["matrix_invite_user"] = mx.get("invite_user", "")
 
     return flat
 
@@ -208,7 +208,7 @@ def load_config(
             token_env=token_env,
             verbose=bool(values.get("matrix_verbose", False)),
             registration_token_env=registration_token_env,
-            bot_username=str(values.get("matrix_bot_username", "")),
+            invite_user=str(values.get("matrix_invite_user", "")),
         )
 
     obs_cfg = ObservabilityConfig(

{hyperloop-0.8.1 → hyperloop-0.9.1}/uv.lock

@@ -120,7 +120,7 @@ wheels = [
 
 [[package]]
 name = "hyperloop"
-version = "0.8.0"
+version = "0.9.0"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },