hyperagents 1.2.3rc5.post3__py3-none-any.whl

integrations/communication/twilio.py

@@ -0,0 +1,279 @@
+"""TwilioConnector — Twilio messaging integration."""
+
+from __future__ import annotations
+
+import logging
+
+import httpx
+
+from integrations.base import (
+    BaseConnector,
+    ConnectorCapability,
+    ConnectorInfo,
+)
+
+logger = logging.getLogger("hyperclaw.integrations.twilio")
+
+
+class TwilioConnector(BaseConnector):
+    """
+    Twilio messaging connector for SMS, WhatsApp, and voice.
+
+    Required config:
+        - account_sid: Twilio account SID
+        - auth_token: Twilio auth token
+    Optional config:
+        - from_number: Default from phone number
+    """
+
+    def __init__(self, config: dict) -> None:
+        self.config = config
+        self.account_sid = config.get("account_sid", "")
+        self.auth_token = config.get("auth_token", "")
+        self.from_number = config.get("from_number", "")
+
+        if config.get("enabled", False):
+            if not self.account_sid or not self.auth_token:
+                raise ValueError(
+                    "TwilioConnector requires account_sid and auth_token"
+                )
+
+        self._client: httpx.AsyncClient | None = None
+
+    @property
+    def info(self) -> ConnectorInfo:
+        return ConnectorInfo(
+            connector_id="twilio",
+            platform="twilio",
+            category="communication",
+            capabilities=frozenset(
+                [
+                    ConnectorCapability.SEND_MESSAGE,
+                    ConnectorCapability.RECEIVE_MESSAGE,
+                    ConnectorCapability.ACTION,
+                    ConnectorCapability.WEBHOOKS,
+                ]
+            ),
+            auth_type="api_key",
+            rate_limit_per_minute=100,
+        )
+
+    @property
+    def _base_url(self) -> str:
+        return f"https://api.twilio.com/2010-04-01/Accounts/{self.account_sid}"
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        if self._client is None:
+            self._client = httpx.AsyncClient(
+                timeout=30.0,
+                auth=(self.account_sid, self.auth_token),
+            )
+        return self._client
+
+    async def health(self) -> bool:
+        """Check if Twilio API is accessible."""
+        try:
+            client = await self._get_client()
+            response = await client.get(f"{self._base_url}.json")
+            return response.status_code == 200
+        except Exception as e:
+            logger.error(f"Twilio health check failed: {e}")
+            return False
+
+    async def send_sms(
+        self,
+        to: str,
+        body: str,
+        from_: str | None = None,
+    ) -> dict:
+        """Send an SMS message."""
+        client = await self._get_client()
+
+        data = {
+            "To": to,
+            "Body": body,
+            "From": from_ or self.from_number,
+        }
+
+        response = await client.post(
+            f"{self._base_url}/Messages.json",
+            data=data,
+        )
+
+        if response.status_code not in (200, 201):
+            raise Exception(f"Twilio send_sms failed: {response.text}")
+
+        return response.json()
+
+    async def send_whatsapp(
+        self,
+        to: str,
+        body: str,
+        from_: str | None = None,
+    ) -> dict:
+        """Send a WhatsApp message via Twilio."""
+        client = await self._get_client()
+
+        # Add whatsapp: prefix if not present
+        if not to.startswith("whatsapp:"):
+            to = f"whatsapp:{to}"
+
+        from_num = from_ or self.from_number
+        if not from_num.startswith("whatsapp:"):
+            from_num = f"whatsapp:{from_num}"
+
+        data = {
+            "To": to,
+            "Body": body,
+            "From": from_num,
+        }
+
+        response = await client.post(
+            f"{self._base_url}/Messages.json",
+            data=data,
+        )
+
+        if response.status_code not in (200, 201):
+            raise Exception(f"Twilio send_whatsapp failed: {response.text}")
+
+        return response.json()
+
+    async def make_call(
+        self,
+        to: str,
+        from_: str,
+        url: str,
+    ) -> dict:
+        """Make a voice call."""
+        client = await self._get_client()
+
+        data = {
+            "To": to,
+            "From": from_,
+            "Url": url,
+        }
+
+        response = await client.post(
+            f"{self._base_url}/Calls.json",
+            data=data,
+        )
+
+        if response.status_code not in (200, 201):
+            raise Exception(f"Twilio make_call failed: {response.text}")
+
+        return response.json()
+
+    async def send_mms(
+        self,
+        to: str,
+        body: str,
+        media_url: str,
+        from_: str | None = None,
+    ) -> dict:
+        """Send an MMS message with media."""
+        client = await self._get_client()
+
+        data = {
+            "To": to,
+            "Body": body,
+            "From": from_ or self.from_number,
+            "MediaUrl": media_url,
+        }
+
+        response = await client.post(
+            f"{self._base_url}/Messages.json",
+            data=data,
+        )
+
+        if response.status_code not in (200, 201):
+            raise Exception(f"Twilio send_mms failed: {response.text}")
+
+        return response.json()
+
+    async def list_messages(self, limit: int = 20) -> dict:
+        """List recent messages."""
+        client = await self._get_client()
+
+        response = await client.get(
+            f"{self._base_url}/Messages.json",
+            params={"PageSize": limit},
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Twilio list_messages failed: {response.text}")
+
+        return response.json()
+
+    async def get_message(self, message_sid: str) -> dict:
+        """Get a specific message."""
+        client = await self._get_client()
+
+        response = await client.get(
+            f"{self._base_url}/Messages/{message_sid}.json"
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Twilio get_message failed: {response.text}")
+
+        return response.json()
+
+    async def list_calls(self, limit: int = 20) -> dict:
+        """List recent calls."""
+        client = await self._get_client()
+
+        response = await client.get(
+            f"{self._base_url}/Calls.json",
+            params={"PageSize": limit},
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Twilio list_calls failed: {response.text}")
+
+        return response.json()
+
+    async def _read_impl(self, resource_id: str, **kwargs) -> dict:
+        """Read a message."""
+        return await self.get_message(resource_id)
+
+    async def _list_impl(
+        self, resource_type: str, filters: dict, **kwargs
+    ) -> list[dict]:
+        """List resources."""
+        limit = filters.get("limit", 20)
+        if resource_type == "messages":
+            result = await self.list_messages(limit)
+            return result.get("messages", [])
+        elif resource_type == "calls":
+            result = await self.list_calls(limit)
+            return result.get("calls", [])
+        return []
+
+    async def _action_impl(self, action_name: str, params: dict) -> dict:
+        """Execute Twilio-specific actions."""
+        if action_name == "send_sms":
+            return await self.send_sms(
+                to=params.get("to"),
+                body=params.get("body", ""),
+                from_=params.get("from"),
+            )
+        elif action_name == "send_whatsapp":
+            return await self.send_whatsapp(
+                to=params.get("to"),
+                body=params.get("body", ""),
+                from_=params.get("from"),
+            )
+        elif action_name == "make_call":
+            return await self.make_call(
+                to=params.get("to"),
+                from_=params.get("from"),
+                url=params.get("url"),
+            )
+        elif action_name == "send_mms":
+            return await self.send_mms(
+                to=params.get("to"),
+                body=params.get("body", ""),
+                media_url=params.get("media_url"),
+                from_=params.get("from"),
+            )
+
+        raise ValueError(f"Unknown action: {action_name}")

integrations/communication/zoom.py

@@ -0,0 +1,290 @@
+"""ZoomConnector — Zoom video conferencing integration."""
+
+from __future__ import annotations
+
+import base64
+import logging
+
+import httpx
+
+from integrations.base import (
+    BaseConnector,
+    ConnectorCapability,
+    ConnectorInfo,
+)
+
+logger = logging.getLogger("hyperclaw.integrations.zoom")
+
+
+class ZoomConnector(BaseConnector):
+    """
+    Zoom video conferencing connector.
+
+    Required config:
+        - account_id: Zoom account ID
+        - client_id: OAuth2 client ID
+        - client_secret: OAuth2 client secret
+    """
+
+    BASE_URL = "https://api.zoom.us/v2"
+    OAUTH_URL = "https://zoom.us/oauth/token"
+
+    def __init__(self, config: dict) -> None:
+        self.config = config
+        self.account_id = config.get("account_id", "")
+        self.client_id = config.get("client_id", "")
+        self.client_secret = config.get("client_secret", "")
+        self._access_token: str | None = None
+
+        if config.get("enabled", False):
+            if not all([self.account_id, self.client_id, self.client_secret]):
+                raise ValueError(
+                    "ZoomConnector requires account_id, client_id, and client_secret"
+                )
+
+        self._client: httpx.AsyncClient | None = None
+
+    @property
+    def info(self) -> ConnectorInfo:
+        return ConnectorInfo(
+            connector_id="zoom",
+            platform="zoom",
+            category="communication",
+            capabilities=frozenset(
+                [
+                    ConnectorCapability.READ_DATA,
+                    ConnectorCapability.WRITE_DATA,
+                    ConnectorCapability.LIST_DATA,
+                    ConnectorCapability.ACTION,
+                    ConnectorCapability.WEBHOOKS,
+                ]
+            ),
+            auth_type="oauth2",
+            rate_limit_per_minute=100,
+        )
+
+    async def _get_access_token(self) -> str:
+        """Get OAuth2 access token using Server-to-Server OAuth."""
+        if self._access_token:
+            return self._access_token
+
+        credentials = base64.b64encode(
+            f"{self.client_id}:{self.client_secret}".encode()
+        ).decode()
+
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.post(
+                self.OAUTH_URL,
+                headers={
+                    "Authorization": f"Basic {credentials}",
+                    "Content-Type": "application/x-www-form-urlencoded",
+                },
+                data={
+                    "grant_type": "account_credentials",
+                    "account_id": self.account_id,
+                },
+            )
+
+            if response.status_code != 200:
+                raise Exception(f"Zoom OAuth failed: {response.text}")
+
+            data = response.json()
+            self._access_token = data.get("access_token", "")
+            return self._access_token
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        if self._client is None:
+            token = await self._get_access_token()
+            self._client = httpx.AsyncClient(
+                timeout=30.0,
+                headers={
+                    "Authorization": f"Bearer {token}",
+                    "Content-Type": "application/json",
+                },
+            )
+        return self._client
+
+    async def health(self) -> bool:
+        """Check if Zoom API is accessible."""
+        try:
+            client = await self._get_client()
+            response = await client.get(f"{self.BASE_URL}/users/me")
+            return response.status_code == 200
+        except Exception as e:
+            logger.error(f"Zoom health check failed: {e}")
+            return False
+
+    async def list_meetings(self, user_id: str = "me") -> dict:
+        """List meetings for a user."""
+        client = await self._get_client()
+
+        response = await client.get(f"{self.BASE_URL}/users/{user_id}/meetings")
+
+        if response.status_code != 200:
+            raise Exception(f"Zoom list_meetings failed: {response.text}")
+
+        return response.json()
+
+    async def create_meeting(
+        self,
+        topic: str,
+        start_time: str,
+        duration: int = 60,
+        agenda: str = "",
+    ) -> dict:
+        """Create a meeting."""
+        client = await self._get_client()
+
+        payload = {
+            "topic": topic,
+            "type": 2,  # Scheduled meeting
+            "start_time": start_time,
+            "duration": duration,
+            "timezone": "UTC",
+        }
+        if agenda:
+            payload["agenda"] = agenda
+
+        response = await client.post(
+            f"{self.BASE_URL}/users/me/meetings",
+            json=payload,
+        )
+
+        if response.status_code not in (200, 201):
+            raise Exception(f"Zoom create_meeting failed: {response.text}")
+
+        return response.json()
+
+    async def get_meeting(self, meeting_id: str) -> dict:
+        """Get meeting details."""
+        client = await self._get_client()
+
+        response = await client.get(f"{self.BASE_URL}/meetings/{meeting_id}")
+
+        if response.status_code != 200:
+            raise Exception(f"Zoom get_meeting failed: {response.text}")
+
+        return response.json()
+
+    async def list_recordings(self, user_id: str = "me") -> dict:
+        """List recordings for a user."""
+        client = await self._get_client()
+
+        response = await client.get(f"{self.BASE_URL}/users/{user_id}/recordings")
+
+        if response.status_code != 200:
+            raise Exception(f"Zoom list_recordings failed: {response.text}")
+
+        return response.json()
+
+    async def get_transcript(self, meeting_id: str) -> dict:
+        """Get transcript for a meeting recording."""
+        client = await self._get_client()
+
+        # First get the recording details
+        response = await client.get(
+            f"{self.BASE_URL}/meetings/{meeting_id}/recordings"
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Zoom get_transcript failed: {response.text}")
+
+        data = response.json()
+
+        # Find VTT transcript file
+        for file in data.get("recording_files", []):
+            if file.get("file_type") == "TRANSCRIPT":
+                return file
+
+        return data
+
+    async def list_webinars(self, user_id: str = "me") -> dict:
+        """List webinars for a user."""
+        client = await self._get_client()
+
+        response = await client.get(f"{self.BASE_URL}/users/{user_id}/webinars")
+
+        if response.status_code != 200:
+            raise Exception(f"Zoom list_webinars failed: {response.text}")
+
+        return response.json()
+
+    async def send_chat_message(
+        self,
+        to_jid: str,
+        message: str,
+        channel_id: str | None = None,
+    ) -> dict:
+        """Send a chat message."""
+        client = await self._get_client()
+
+        payload = {"message": message}
+        if channel_id:
+            payload["to_channel"] = channel_id
+        else:
+            payload["to_jid"] = to_jid
+
+        response = await client.post(
+            f"{self.BASE_URL}/chat/users/me/messages",
+            json=payload,
+        )
+
+        if response.status_code not in (200, 201):
+            raise Exception(f"Zoom send_chat_message failed: {response.text}")
+
+        return response.json()
+
+    async def _read_impl(self, resource_id: str, **kwargs) -> dict:
+        """Read meeting details."""
+        return await self.get_meeting(resource_id)
+
+    async def _write_impl(self, resource_type: str, data: dict, **kwargs) -> dict:
+        """Create a meeting."""
+        if resource_type == "meeting":
+            return await self.create_meeting(
+                topic=data.get("topic", "Meeting"),
+                start_time=data.get("start_time"),
+                duration=data.get("duration", 60),
+                agenda=data.get("agenda", ""),
+            )
+        elif resource_type == "chat_message":
+            return await self.send_chat_message(
+                to_jid=data.get("to_jid", ""),
+                message=data.get("message", ""),
+                channel_id=data.get("channel_id"),
+            )
+        raise ValueError(f"Unknown resource type: {resource_type}")
+
+    async def _list_impl(
+        self, resource_type: str, filters: dict, **kwargs
+    ) -> list[dict]:
+        """List resources."""
+        user_id = filters.get("user_id", "me")
+        if resource_type == "meetings":
+            result = await self.list_meetings(user_id)
+            return result.get("meetings", [])
+        elif resource_type == "recordings":
+            result = await self.list_recordings(user_id)
+            return result.get("meetings", [])
+        elif resource_type == "webinars":
+            result = await self.list_webinars(user_id)
+            return result.get("webinars", [])
+        return []
+
+    async def _action_impl(self, action_name: str, params: dict) -> dict:
+        """Execute Zoom-specific actions."""
+        if action_name == "create_meeting":
+            return await self.create_meeting(
+                topic=params.get("topic", "Meeting"),
+                start_time=params.get("start_time"),
+                duration=params.get("duration", 60),
+                agenda=params.get("agenda", ""),
+            )
+        elif action_name == "send_chat":
+            return await self.send_chat_message(
+                to_jid=params.get("to_jid", ""),
+                message=params.get("message", ""),
+                channel_id=params.get("channel_id"),
+            )
+
+        raise ValueError(f"Unknown action: {action_name}")

integrations/data/__init__.py

@@ -0,0 +1 @@
+# Data integrations

integrations/data/google_analytics.py

@@ -0,0 +1,135 @@
+"""GoogleAnalyticsConnector — Google Analytics Data API integration."""
+
+from __future__ import annotations
+
+import logging
+
+import httpx
+
+from integrations.base import (
+    BaseConnector,
+    ConnectorCapability,
+    ConnectorInfo,
+)
+from integrations.productivity.google.base import GoogleOAuthBase
+
+logger = logging.getLogger("hyperclaw.integrations.google_analytics")
+
+
+class GoogleAnalyticsConnector(GoogleOAuthBase, BaseConnector):
+    """
+    Google Analytics Data API connector.
+
+    Required config:
+        - service_account_file: Path to service account JSON
+        OR
+        - access_token: OAuth2 access token
+    """
+
+    DATA_API_URL = "https://analyticsdata.googleapis.com/v1beta"
+    ADMIN_API_URL = "https://analyticsadmin.googleapis.com/v1alpha"
+
+    def __init__(self, config: dict) -> None:
+        self.config = config
+        self._init_google_auth(config)
+
+        if config.get("enabled", False):
+            self._validate_google_config(config)
+
+    @property
+    def info(self) -> ConnectorInfo:
+        return ConnectorInfo(
+            connector_id="google_analytics",
+            platform="google_analytics",
+            category="data",
+            capabilities=frozenset(
+                [
+                    ConnectorCapability.READ_DATA,
+                    ConnectorCapability.LIST_DATA,
+                ]
+            ),
+            auth_type="oauth2",
+            rate_limit_per_minute=60,
+        )
+
+    async def health(self) -> bool:
+        """Check if Google Analytics API is accessible."""
+        return True
+
+    async def run_report(
+        self,
+        property_id: str,
+        dimensions: list[str],
+        metrics: list[str],
+        date_range: dict,
+    ) -> dict:
+        """Run a Google Analytics report."""
+        client = await self._get_google_client()
+
+        payload = {
+            "dimensions": [{"name": d} for d in dimensions],
+            "metrics": [{"name": m} for m in metrics],
+            "dateRanges": [date_range],
+        }
+
+        response = await client.post(
+            f"{self.DATA_API_URL}/properties/{property_id}:runReport",
+            json=payload,
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Google Analytics run_report failed: {response.text}")
+
+        return response.json()
+
+    async def get_realtime(self, property_id: str) -> dict:
+        """Get realtime analytics data."""
+        client = await self._get_google_client()
+
+        payload = {
+            "dimensions": [{"name": "country"}],
+            "metrics": [{"name": "activeUsers"}],
+        }
+
+        response = await client.post(
+            f"{self.DATA_API_URL}/properties/{property_id}:runRealtimeReport",
+            json=payload,
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Google Analytics get_realtime failed: {response.text}")
+
+        return response.json()
+
+    async def list_properties(self) -> dict:
+        """List all Google Analytics properties."""
+        client = await self._get_google_client()
+
+        response = await client.get(f"{self.ADMIN_API_URL}/accountSummaries")
+
+        if response.status_code != 200:
+            raise Exception(
+                f"Google Analytics list_properties failed: {response.text}"
+            )
+
+        return response.json()
+
+    async def _read_impl(self, resource_id: str, **kwargs) -> dict:
+        """Read analytics data for a property."""
+        dimensions = kwargs.get("dimensions", ["date"])
+        metrics = kwargs.get("metrics", ["sessions"])
+        date_range = kwargs.get("date_range", {
+            "startDate": "30daysAgo",
+            "endDate": "today",
+        })
+
+        return await self.run_report(resource_id, dimensions, metrics, date_range)
+
+    async def _list_impl(
+        self, resource_type: str, filters: dict, **kwargs
+    ) -> list[dict]:
+        """List properties."""
+        if resource_type == "properties":
+            result = await self.list_properties()
+            return result.get("accountSummaries", [])
+        return []