webex-message-handler 0.4.3__tar.gz → 0.5.0__tar.gz

{webex_message_handler-0.4.3 → webex_message_handler-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webex-message-handler
-Version: 0.4.3
+Version: 0.5.0
 Summary: Lightweight Webex Mercury WebSocket + KMS decryption for receiving bot messages without the full Webex SDK
 Project-URL: Homepage, https://github.com/3rg0n/webex-message-handler
 Project-URL: Repository, https://github.com/3rg0n/webex-message-handler

{webex_message_handler-0.4.3 → webex_message_handler-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "webex-message-handler"
-version = "0.4.3"
+version = "0.5.0"
 description = "Lightweight Webex Mercury WebSocket + KMS decryption for receiving bot messages without the full Webex SDK"
 readme = "README.md"
 license = "MIT"

{webex_message_handler-0.4.3 → webex_message_handler-0.5.0}/src/webex_message_handler/__init__.py

@@ -24,6 +24,7 @@ from .types import (
     FetchResponse,
     HandlerStatus,
     InjectedWebSocket,
+    MembershipActivity,
     MercuryActivity,
     MercuryActor,
     MercuryEnvelope,
@@ -63,6 +64,7 @@ __all__ = [
     "MercuryEnvelope",
     "DecryptedMessage",
     "DeletedMessage",
+    "MembershipActivity",
     "HandlerStatus",
     "ConnectionStatus",
     # Networking types

{webex_message_handler-0.4.3 → webex_message_handler-0.5.0}/src/webex_message_handler/handler.py

@@ -23,6 +23,7 @@ from .types import (
     FetchResponse,
     HandlerStatus,
     InjectedWebSocket,
+    MembershipActivity,
     MercuryActivity,
     WebexMessageHandlerConfig,
     WebSocketFactory,
@@ -131,6 +132,7 @@ class WebexMessageHandler:
         self._listeners: dict[str, list[EventCallback]] = {
             "message:created": [],
             "message:deleted": [],
+            "membership:created": [],
             "connected": [],
             "disconnected": [],
             "reconnecting": [],
@@ -452,7 +454,11 @@ class WebexMessageHandler:
                 raw=decrypted,
             )
             # Filter self-messages if enabled
-            if self._ignore_self_messages and self._bot_person_id and extract_person_uuid(message.person_id) == self._bot_person_id:
+            if (
+                self._ignore_self_messages
+                and self._bot_person_id
+                and extract_person_uuid(message.person_id) == self._bot_person_id
+            ):
                 self._logger.debug(f"Ignoring self-message from bot ({self._bot_person_id})")
                 return
 
@@ -469,6 +475,24 @@ class WebexMessageHandler:
                     person_id=activity.actor.id,
                 ),
             )
+            return
+
+        # membership:created — membership verbs + objectType=person
+        membership_verbs = {"add", "leave", "assignModerator", "unassignModerator"}
+        if activity.verb in membership_verbs and activity.object.object_type == "person":
+            self._emit(
+                "membership:created",
+                MembershipActivity(
+                    id=activity.id,
+                    actor_id=activity.actor.id,
+                    person_id=activity.object.id,
+                    room_id=activity.target.id,
+                    action=activity.verb,
+                    created=activity.published,
+                    room_type=self._infer_room_type(activity),
+                    raw=activity,
+                ),
+            )
 
     @staticmethod
     def _infer_room_type(activity: MercuryActivity) -> str | None:

{webex_message_handler-0.4.3 → webex_message_handler-0.5.0}/src/webex_message_handler/kms_client.py

@@ -141,13 +141,18 @@ class KmsClient:
             response_body = _unwrap_kms_response(wrapped_response, local_ecdh_key)
             response_data = json.loads(response_body)
 
-            remote_jwk_data = response_data.get("body", {}).get("key", {}).get("jwk") or response_data.get("key", {}).get("jwk")
-            if not remote_jwk_data:
-                # Try alternate response structures
-                if "body" in response_data and "key" in response_data["body"]:
-                    remote_jwk_data = response_data["body"]["key"]
-                    if isinstance(remote_jwk_data, dict) and "jwk" in remote_jwk_data:
-                        remote_jwk_data = remote_jwk_data["jwk"]
+            remote_jwk_data = (
+                response_data.get("body", {}).get("key", {}).get("jwk")
+                or response_data.get("key", {}).get("jwk")
+            )
+            if (
+                not remote_jwk_data
+                and "body" in response_data
+                and "key" in response_data["body"]
+            ):
+                remote_jwk_data = response_data["body"]["key"]
+                if isinstance(remote_jwk_data, dict) and "jwk" in remote_jwk_data:
+                    remote_jwk_data = remote_jwk_data["jwk"]
 
             if not remote_jwk_data:
                 raise KmsError(
@@ -155,7 +160,10 @@ class KmsClient:
                 )
 
             # Step 7: Derive shared key via ECDH
-            remote_ecdh_key = jwk.JWK(**remote_jwk_data) if isinstance(remote_jwk_data, dict) else jwk.JWK(**json.loads(remote_jwk_data))
+            if isinstance(remote_jwk_data, dict):
+                remote_ecdh_key = jwk.JWK(**remote_jwk_data)
+            else:
+                remote_ecdh_key = jwk.JWK(**json.loads(remote_jwk_data))
 
             # Get the remote key URI for use as kid on the derived key
             remote_key_uri = (
@@ -239,14 +247,17 @@ class KmsClient:
             response_data = json.loads(response_body)
 
             # Extract the content key
-            key_data = response_data.get("body", {}).get("key", {}).get("jwk") or response_data.get("key", {}).get("jwk")
-            if not key_data:
-                if "body" in response_data and "key" in response_data["body"]:
-                    key_obj = response_data["body"]["key"]
-                    if isinstance(key_obj, dict) and "jwk" in key_obj:
-                        key_data = key_obj["jwk"]
-                    else:
-                        key_data = key_obj
+            key_data = (
+                response_data.get("body", {}).get("key", {}).get("jwk")
+                or response_data.get("key", {}).get("jwk")
+            )
+            if (
+                not key_data
+                and "body" in response_data
+                and "key" in response_data["body"]
+            ):
+                key_obj = response_data["body"]["key"]
+                key_data = key_obj["jwk"] if isinstance(key_obj, dict) and "jwk" in key_obj else key_obj
 
             if not key_data:
                 raise KmsError("No key found in KMS response")
@@ -370,8 +381,6 @@ def _derive_ecdh_shared_key(local_key: jwk.JWK, remote_key: jwk.JWK, *, kid: str
     from cryptography.hazmat.primitives.hashes import SHA256
     from cryptography.hazmat.primitives.kdf.hkdf import HKDF
 
-    # Get cryptography private key from local JWK
-    local_private = local_key.get_op_key("sign") if local_key.has_private else local_key.get_op_key("unwrapKey")
     # For EC keys, get the actual private key object
     local_crypto_key = local_key._get_private_key() if hasattr(local_key, '_get_private_key') else None
 

{webex_message_handler-0.4.3 → webex_message_handler-0.5.0}/src/webex_message_handler/mercury_socket.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import json
 import math
 import uuid
@@ -10,6 +11,8 @@ from collections.abc import Callable
 from typing import Any
 from urllib.parse import parse_qs, urlencode, urlparse, urlunparse
 
+import aiohttp
+
 from .errors import AuthError, MercuryConnectionError
 from .logger import Logger, noop_logger
 from .types import InjectedWebSocket, MercuryActivity, MercuryActor, MercuryObject, MercuryTarget, WebSocketFactory
@@ -104,7 +107,7 @@ class MercurySocket:
             "type": "authorization",
             "data": {"token": f"Bearer {self._token}"},
         })
-        await self._ws.send(auth_message)
+        await self._ws.send_str(auth_message)
 
         # Start read loop in background
         async def _read_loop() -> None:
@@ -158,9 +161,9 @@ class MercurySocket:
         # Wait for connection ready or error
         try:
             await asyncio.wait_for(ready_event.wait(), timeout=30.0)
-        except asyncio.TimeoutError:
+        except asyncio.TimeoutError as exc:
             await self._cleanup_ws()
-            raise MercuryConnectionError("Mercury connection timeout waiting for ready signal")
+            raise MercuryConnectionError("Mercury connection timeout waiting for ready signal") from exc
 
         if connect_error:
             await self._cleanup_ws()
@@ -193,7 +196,7 @@ class MercurySocket:
                         "type": "ping",
                     })
                     try:
-                        await self._ws.send(ping_message)
+                        await self._ws.send_str(ping_message)
                     except Exception:
                         break
                     self._logger.debug(f"Sent ping: {self._pending_pong_id}")
@@ -329,16 +332,14 @@ class MercurySocket:
 
     async def _close_websocket(self) -> None:
         if self._ws and not self._ws.closed:
-            await self._ws.close(code=aiohttp.WSCloseCode.OK)
+            await self._ws.close(code=1000)
 
     async def _cleanup_ws(self) -> None:
         self._stop_ping_loop()
         if self._read_task and not self._read_task.done():
             self._read_task.cancel()
-            try:
+            with contextlib.suppress(asyncio.CancelledError):
                 await self._read_task
-            except asyncio.CancelledError:
-                pass
         await self._close_websocket()
         self._ws = None
 
@@ -349,10 +350,8 @@ class MercurySocket:
         self._stop_ping_loop()
         if self._read_task and not self._read_task.done():
             self._read_task.cancel()
-            try:
+            with contextlib.suppress(asyncio.CancelledError):
                 await self._read_task
-            except asyncio.CancelledError:
-                pass
         await self._close_websocket()
         self._ws = None
         self._connection_ready = False

{webex_message_handler-0.4.3 → webex_message_handler-0.5.0}/src/webex_message_handler/message_decryptor.py

@@ -53,7 +53,11 @@ class MessageDecryptor:
             decrypted.object = copy.copy(activity.object)
 
             # Decrypt displayName
-            if decrypted.object.display_name and isinstance(decrypted.object.display_name, str) and len(decrypted.object.display_name) > 0:
+            if (
+                decrypted.object.display_name
+                and isinstance(decrypted.object.display_name, str)
+                and len(decrypted.object.display_name) > 0
+            ):
                 try:
                     jwe_obj = jwe.JWE()
                     jwe_obj.deserialize(decrypted.object.display_name, key=key)
@@ -64,7 +68,11 @@ class MessageDecryptor:
                     )
 
             # Decrypt content
-            if decrypted.object.content and isinstance(decrypted.object.content, str) and len(decrypted.object.content) > 0:
+            if (
+                decrypted.object.content
+                and isinstance(decrypted.object.content, str)
+                and len(decrypted.object.content) > 0
+            ):
                 try:
                     jwe_obj = jwe.JWE()
                     jwe_obj.deserialize(decrypted.object.content, key=key)

{webex_message_handler-0.4.3 → webex_message_handler-0.5.0}/src/webex_message_handler/types.py

@@ -2,8 +2,9 @@
 
 from __future__ import annotations
 
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Awaitable, Callable, Literal, Protocol
+from typing import TYPE_CHECKING, Any, Literal, Protocol
 
 if TYPE_CHECKING:
     import aiohttp
@@ -228,6 +229,35 @@ class DeletedMessage:
     person_id: str
 
 
+@dataclass
+class MembershipActivity:
+    """A membership activity from Mercury."""
+
+    id: str
+    """Activity ID."""
+
+    actor_id: str
+    """ID of the person who performed the action."""
+
+    person_id: str
+    """ID of the member affected."""
+
+    room_id: str
+    """Conversation/space ID."""
+
+    action: str
+    """Membership action: "add", "leave", "assignModerator", or "unassignModerator"."""
+
+    created: str
+    """ISO 8601 timestamp."""
+
+    room_type: str | None = None
+    """'direct' | 'group' | None."""
+
+    raw: MercuryActivity | None = None
+    """Full raw activity for advanced use."""
+
+
 # --- Status ---
 
 ConnectionStatus = Literal["connected", "connecting", "reconnecting", "disconnected"]

{webex_message_handler-0.4.3 → webex_message_handler-0.5.0}/tests/conftest.py

@@ -8,13 +8,15 @@ from webex_message_handler.types import FetchRequest, FetchResponse
 async def create_test_http_do(connector: aiohttp.BaseConnector | None = None):
     """Create a test HTTP adapter for use in tests."""
     async def http_do(request: FetchRequest) -> FetchResponse:
-        async with aiohttp.ClientSession(connector=connector) as session:
-            async with session.request(
+        async with (
+            aiohttp.ClientSession(connector=connector) as session,
+            session.request(
                 request.method,
                 request.url,
                 headers=request.headers,
                 data=request.body,
-            ) as response:
+            ) as response,
+        ):
                 # Eagerly read the response body before the context closes
                 body_bytes = await response.read()
                 status = response.status

{webex_message_handler-0.4.3 → webex_message_handler-0.5.0}/tests/test_handler.py

@@ -6,7 +6,6 @@ import pytest
 
 from webex_message_handler.handler import WebexMessageHandler
 from webex_message_handler.types import (
-    DecryptedMessage,
     DeviceRegistration,
     MercuryActivity,
     MercuryActor,
@@ -37,7 +36,10 @@ def _make_activity(**overrides) -> MercuryActivity:
         "id": "msg-123",
         "verb": "post",
         "actor": MercuryActor(id="person-456", object_type="person", email_address="user@example.com"),
-        "object": MercuryObject(id="comment-789", object_type="comment", display_name="Test Message", content="<p>Test Message</p>"),
+        "object": MercuryObject(
+            id="comment-789", object_type="comment",
+            display_name="Test Message", content="<p>Test Message</p>",
+        ),
         "target": MercuryTarget(id="room-101", object_type="conversation", tags=["GROUP"]),
         "published": "2024-01-01T00:00:00Z",
     }
@@ -282,6 +284,118 @@ class TestMessageHandling:
         assert len(messages) == 0
 
 
+class TestMembershipHandling:
+    async def test_handle_membership_add(self):
+        handler = _make_handler()
+        activity = _make_activity(
+            verb="add",
+            object=MercuryObject(id="member-789", object_type="person"),
+        )
+
+        events = []
+        handler.on("membership:created", lambda a: events.append(a))
+
+        await handler._handle_activity(activity)
+
+        assert len(events) == 1
+        evt = events[0]
+        assert evt.id == "msg-123"
+        assert evt.actor_id == "person-456"
+        assert evt.person_id == "member-789"
+        assert evt.room_id == "room-101"
+        assert evt.action == "add"
+        assert evt.created == "2024-01-01T00:00:00Z"
+        assert evt.room_type == "group"
+
+    async def test_handle_membership_leave(self):
+        handler = _make_handler()
+        activity = _make_activity(
+            verb="leave",
+            object=MercuryObject(id="member-789", object_type="person"),
+        )
+
+        events = []
+        handler.on("membership:created", lambda a: events.append(a))
+
+        await handler._handle_activity(activity)
+
+        assert len(events) == 1
+        assert events[0].action == "leave"
+
+    async def test_handle_membership_assign_moderator(self):
+        handler = _make_handler()
+        activity = _make_activity(
+            verb="assignModerator",
+            object=MercuryObject(id="member-789", object_type="person"),
+        )
+
+        events = []
+        handler.on("membership:created", lambda a: events.append(a))
+
+        await handler._handle_activity(activity)
+
+        assert len(events) == 1
+        assert events[0].action == "assignModerator"
+
+    async def test_handle_membership_unassign_moderator(self):
+        handler = _make_handler()
+        activity = _make_activity(
+            verb="unassignModerator",
+            object=MercuryObject(id="member-789", object_type="person"),
+        )
+
+        events = []
+        handler.on("membership:created", lambda a: events.append(a))
+
+        await handler._handle_activity(activity)
+
+        assert len(events) == 1
+        assert events[0].action == "unassignModerator"
+
+    async def test_non_membership_verb_with_person_object(self):
+        handler = _make_handler()
+        activity = _make_activity(
+            verb="post",
+            object=MercuryObject(id="person-789", object_type="person"),
+        )
+
+        events = []
+        handler.on("membership:created", lambda a: events.append(a))
+
+        await handler._handle_activity(activity)
+
+        assert len(events) == 0
+
+    async def test_membership_verb_with_non_person_object(self):
+        handler = _make_handler()
+        activity = _make_activity(
+            verb="add",
+            object=MercuryObject(id="comment-789", object_type="comment"),
+        )
+
+        events = []
+        handler.on("membership:created", lambda a: events.append(a))
+
+        await handler._handle_activity(activity)
+
+        assert len(events) == 0
+
+    async def test_membership_includes_raw_activity(self):
+        handler = _make_handler()
+        activity = _make_activity(
+            verb="add",
+            object=MercuryObject(id="member-789", object_type="person"),
+        )
+
+        events = []
+        handler.on("membership:created", lambda a: events.append(a))
+
+        await handler._handle_activity(activity)
+
+        assert len(events) == 1
+        assert events[0].raw is activity
+
+
 class TestStatus:
     def test_disconnected_status(self):
         handler = _make_handler()

{webex_message_handler-0.4.3 → webex_message_handler-0.5.0}/tests/test_integration.py

@@ -81,7 +81,9 @@ async def test_integration_send_and_receive():
                 "https://webexapis.com/v1/people/me",
                 headers={"Authorization": f"Bearer {sender_token}"}
             ) as sender_response:
-                assert receiver_response.status == 200, f"Failed to get receiver bot identity: {receiver_response.status}"
+                assert receiver_response.status == 200, (
+                    f"Failed to get receiver bot identity: {receiver_response.status}"
+                )
                 assert sender_response.status == 200, f"Failed to get sender bot identity: {sender_response.status}"
                 receiver = await receiver_response.json()
                 sender = await sender_response.json()

{webex_message_handler-0.4.3 → webex_message_handler-0.5.0}/tests/test_message_decryptor.py

@@ -55,7 +55,6 @@ class TestDecryptActivity:
             mock_jwe_obj2.payload = b"decrypted-content"
 
             call_count = [0]
-            original_init = mock_jwe.JWE
 
             def side_effect():
                 call_count[0] += 1