hyperloop 0.8.0__tar.gz → 0.9.0__tar.gz

{hyperloop-0.8.0 → hyperloop-0.9.0}/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 <!-- version list -->
 
+## v0.9.0 (2026-04-15)
+
+
+## v0.8.1 (2026-04-15)
+
+### Bug Fixes
+
+- **matrix**: Auto-create room independently of registration
+  ([`cb4c0a6`](https://github.com/jsell-rh/hyperloop/commit/cb4c0a665a018a6739ff0fb70e333e7f69202e54))
+
+
 ## v0.8.0 (2026-04-15)
 
 ### Features

{hyperloop-0.8.0 → hyperloop-0.9.0}/PKG-INFO

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

{hyperloop-0.8.0 → hyperloop-0.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hyperloop"
-version = "0.8.0"
+version = "0.9.0"
 description = "Orchestrator that walks tasks through composable process pipelines using AI agents"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -57,6 +57,7 @@ ignore = []
 pythonVersion = "3.12"
 typeCheckingMode = "strict"
 reportMissingTypeStubs = false
+reportPrivateUsage = false
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

{hyperloop-0.8.0 → hyperloop-0.9.0}/src/hyperloop/adapters/matrix_setup.py

@@ -49,6 +49,21 @@ def _load_cache(repo_path: Path, homeserver: str) -> dict[str, str] | None:
         return None
 
 
+def _ensure_gitignored(repo_path: Path) -> None:
+    """Ensure .hyperloop/ is in the target repo's .gitignore."""
+    gitignore = repo_path / ".gitignore"
+    entry = ".hyperloop/"
+    if gitignore.is_file():
+        content = gitignore.read_text()
+        if entry in content.splitlines():
+            return
+        if not content.endswith("\n"):
+            content += "\n"
+        gitignore.write_text(content + entry + "\n")
+    else:
+        gitignore.write_text(entry + "\n")
+
+
 def _save_cache(
     repo_path: Path,
     *,
@@ -59,6 +74,7 @@ def _save_cache(
     password: str,
 ) -> None:
     """Persist Matrix credentials to the cache file."""
+    _ensure_gitignored(repo_path)
     cache_path = repo_path / _CACHE_FILE
     cache_path.parent.mkdir(parents=True, exist_ok=True)
     cache_path.write_text(
@@ -166,15 +182,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,
@@ -197,10 +216,15 @@ def ensure_matrix_ready(
 ) -> tuple[str, str]:
     """Ensure Matrix credentials and room are available.
 
-    Resolution order:
-    1. Explicit ``token_env`` + ``room_id`` in config → use directly (no setup).
-    2. Cached credentials in ``.hyperloop/matrix-state.json`` → reuse.
-    3. ``registration_token`` → register bot, create room, cache.
+    **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.
+
+    **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
@@ -209,82 +233,147 @@ def ensure_matrix_ready(
     import os
 
     homeserver = config.homeserver.rstrip("/")
+    cache = _load_cache(repo_path, homeserver)
 
-    # 1. Explicit token from env takes precedence
+    # --- Resolve access token ---
     explicit_token = os.environ.get(config.token_env) if config.token_env else ""
-    explicit_room = config.room_id
-
-    if explicit_token and explicit_room:
-        return explicit_token, explicit_room
+    access_token = explicit_token
 
-    # 2. Try cache
-    cache = _load_cache(repo_path, homeserver)
-    if cache is not None:
-        cached_token = cache.get("access_token", "")
-        cached_room = cache.get("room_id", "")
-        # Allow explicit overrides to supplement cache
-        token = explicit_token or cached_token
-        room_id = explicit_room or cached_room
-        if token and room_id:
-            return token, room_id
-
-    # 3. Auto-setup via registration_token from env
-    registration_token = (
-        os.environ.get(config.registration_token_env) if config.registration_token_env else ""
-    )
-    if not registration_token:
-        _log.warning(
-            "Matrix: no access token, no cached credentials, and no registration token — skipping"
+    if not access_token:
+        registration_token = (
+            os.environ.get(config.registration_token_env) if config.registration_token_env else ""
         )
+        if registration_token:
+            try:
+                access_token = _register_disposable_bot(
+                    config, repo_path, homeserver, registration_token, cache
+                )
+            except Exception:
+                _log.exception("Matrix bot registration failed")
+        else:
+            _log.warning("Matrix: no access token and no registration token — skipping")
+            return "", ""
+
+    if not access_token:
         return "", ""
 
-    try:
-        return _auto_setup(config, repo_path, homeserver, registration_token, cache)
-    except Exception:
-        _log.exception("Matrix auto-setup failed — skipping Matrix notifications")
-        return "", ""
+    # --- Resolve room_id ---
+    cached_room = cache.get("room_id", "") if cache else ""
+    room_id = config.room_id or cached_room
+
+    if not room_id:
+        try:
+            room_id = _auto_create_room(config, repo_path, homeserver, access_token)
+        except Exception:
+            _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:
+        try:
+            _join_room(httpx.Client(timeout=10.0), homeserver, access_token, room_id)
+        except Exception:
+            _log.exception("Matrix room join failed")
 
+    return access_token, room_id
 
-def _auto_setup(
+
+def _register_disposable_bot(
     config: MatrixConfig,
     repo_path: Path,
     homeserver: str,
     registration_token: str,
     cache: dict[str, str] | None,
-) -> tuple[str, str]:
-    """Register bot, create room, cache credentials. Returns (token, room_id)."""
-    # Derive bot username
-    repo_name = repo_path.name
-    username = config.bot_username or f"hyperloop-{repo_name}"
+) -> str:
+    """Register a fresh disposable bot user. Returns access_token.
 
-    # Reuse cached password if available, otherwise generate one
-    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:
-        # Register or login
+        # 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
         )
 
-        # Create room if needed
-        room_id = config.room_id
-        if not room_id:
-            room_id = _create_room(client, homeserver, access_token, f"hyperloop-{repo_name}")
-
-        # Cache for next run
+        # 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=room_id,
+            room_id=config.room_id or cached_room,
             password=password,
         )
 
-        _log.info("Matrix auto-setup complete: user=%s room=%s", user_id, room_id)
-        return access_token, room_id
+        _log.info("Matrix bot registered: %s", 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, 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}",
+            invite_user=config.invite_user,
+        )
+
+        # Update cache with the new room_id
+        cache = _load_cache(repo_path, homeserver) or {}
+        _save_cache(
+            repo_path,
+            homeserver=homeserver,
+            user_id=cache.get("user_id", ""),
+            access_token=cache.get("access_token", access_token),
+            room_id=room_id,
+            password=cache.get("password", ""),
+        )
+
+        _log.info("Matrix room created: %s", room_id)
+        return room_id
     finally:
         client.close()

{hyperloop-0.8.0 → hyperloop-0.9.0}/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.0 → hyperloop-0.9.0}/tests/fakes/probe.py

@@ -13,7 +13,7 @@ class RecordedCall:
     """A single recorded probe call."""
 
     method: str
-    kwargs: dict[str, object] = field(default_factory=dict)
+    kwargs: dict[str, object] = field(default_factory=lambda: {})
 
 
 class RecordingProbe:

{hyperloop-0.8.0 → hyperloop-0.9.0}/tests/test_compose.py

@@ -343,7 +343,7 @@ class TestCheckKustomize:
     def test_raises_when_missing(self, monkeypatch: pytest.MonkeyPatch) -> None:
         from hyperloop.compose import check_kustomize_available
 
-        monkeypatch.setattr(shutil, "which", lambda _name: None)
+        monkeypatch.setattr(shutil, "which", lambda _name: None)  # type: ignore[arg-type]
 
         with pytest.raises(SystemExit, match="kustomize CLI not found"):
             check_kustomize_available()

{hyperloop-0.8.0 → hyperloop-0.9.0}/uv.lock

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