hyperagents 1.2.3rc5.post3__py3-none-any.whl

integrations/productivity/microsoft/outlook.py

@@ -0,0 +1,241 @@
+"""OutlookConnector — Microsoft Outlook/Mail API integration."""
+
+from __future__ import annotations
+
+import logging
+from typing import AsyncIterator
+
+import httpx
+
+from integrations.base import (
+    BaseConnector,
+    ConnectorCapability,
+    ConnectorInfo,
+    InboundMessage,
+    OutboundMessage,
+)
+from integrations.productivity.microsoft.base import MicrosoftOAuthBase
+
+logger = logging.getLogger("hyperclaw.integrations.outlook")
+
+
+class OutlookConnector(BaseConnector, MicrosoftOAuthBase):
+    """
+    Microsoft Outlook connector via Graph API.
+
+    Required config (via MicrosoftOAuthBase):
+        - access_token OR (client_id + client_secret + tenant_id)
+    """
+
+    def __init__(self, config: dict) -> None:
+        self.config = config
+        self._init_microsoft_auth(config)
+        self._validate_microsoft_config(config)
+
+    @property
+    def info(self) -> ConnectorInfo:
+        return ConnectorInfo(
+            connector_id="outlook",
+            platform="outlook",
+            category="productivity",
+            capabilities=frozenset(
+                [
+                    ConnectorCapability.SEND_MESSAGE,
+                    ConnectorCapability.RECEIVE_MESSAGE,
+                    ConnectorCapability.READ_DATA,
+                    ConnectorCapability.WRITE_DATA,
+                    ConnectorCapability.LIST_DATA,
+                    ConnectorCapability.SEARCH,
+                    ConnectorCapability.FILE_UPLOAD,
+                    ConnectorCapability.FILE_DOWNLOAD,
+                ]
+            ),
+            auth_type="oauth2",
+            rate_limit_per_minute=120,
+            supports_threads=True,
+            supports_attachments=True,
+        )
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        return await self._get_microsoft_client()
+
+    async def health(self) -> bool:
+        """Check if Outlook API is accessible."""
+        try:
+            client = await self._get_client()
+            response = await client.get(f"{self.GRAPH_URL}/me")
+            return response.status_code == 200
+        except Exception as e:
+            logger.error(f"Outlook health check failed: {e}")
+            return False
+
+    async def _send_impl(self, message: OutboundMessage) -> str:
+        """Send an email via Outlook."""
+        return await self.send_email(
+            to=message.recipient_id,
+            subject="Message",
+            body=message.content,
+        )
+
+    async def _receive_impl(self) -> AsyncIterator[InboundMessage]:
+        """Receive emails from inbox."""
+        messages = await self.list_inbox(max_results=20)
+
+        for msg in messages:
+            sender = msg.get("from", {}).get("emailAddress", {})
+
+            yield InboundMessage(
+                message_id=msg.get("id", ""),
+                platform="outlook",
+                sender_id=sender.get("address", ""),
+                sender_name=sender.get("name", sender.get("address", "")),
+                content=msg.get("bodyPreview", ""),
+                thread_id=msg.get("conversationId"),
+                raw=msg,
+            )
+
+    async def send_email(
+        self,
+        to: str,
+        subject: str,
+        body: str,
+        is_html: bool = False,
+    ) -> str:
+        """Send an email."""
+        client = await self._get_client()
+
+        payload = {
+            "message": {
+                "subject": subject,
+                "body": {
+                    "contentType": "HTML" if is_html else "Text",
+                    "content": body,
+                },
+                "toRecipients": [{"emailAddress": {"address": to}}],
+            }
+        }
+
+        response = await client.post(
+            f"{self.GRAPH_URL}/me/sendMail",
+            json=payload,
+        )
+
+        if response.status_code not in (200, 202):
+            raise Exception(f"Outlook send failed: {response.text}")
+
+        return "sent"
+
+    async def list_inbox(
+        self,
+        max_results: int = 20,
+        filter_query: str = "",
+    ) -> list[dict]:
+        """List inbox messages."""
+        client = await self._get_client()
+
+        params = {"$top": max_results, "$orderby": "receivedDateTime desc"}
+        if filter_query:
+            params["$filter"] = filter_query
+
+        response = await client.get(
+            f"{self.GRAPH_URL}/me/messages",
+            params=params,
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Outlook list inbox failed: {response.text}")
+
+        return response.json().get("value", [])
+
+    async def search_emails(self, query: str) -> list[dict]:
+        """Search emails."""
+        client = await self._get_client()
+
+        response = await client.get(
+            f"{self.GRAPH_URL}/me/messages",
+            params={"$search": f'"{query}"', "$top": 50},
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Outlook search failed: {response.text}")
+
+        return response.json().get("value", [])
+
+    async def get_message(self, message_id: str) -> dict:
+        """Get a specific message."""
+        client = await self._get_client()
+
+        response = await client.get(f"{self.GRAPH_URL}/me/messages/{message_id}")
+
+        if response.status_code != 200:
+            raise Exception(f"Outlook get message failed: {response.text}")
+
+        return response.json()
+
+    async def create_draft(
+        self,
+        to: str,
+        subject: str,
+        body: str,
+    ) -> str:
+        """Create an email draft."""
+        client = await self._get_client()
+
+        payload = {
+            "subject": subject,
+            "body": {"contentType": "Text", "content": body},
+            "toRecipients": [{"emailAddress": {"address": to}}],
+        }
+
+        response = await client.post(
+            f"{self.GRAPH_URL}/me/messages",
+            json=payload,
+        )
+
+        if response.status_code not in (200, 201):
+            raise Exception(f"Outlook create draft failed: {response.text}")
+
+        return response.json().get("id", "")
+
+    async def move_to_folder(
+        self,
+        message_id: str,
+        folder_id: str,
+    ) -> bool:
+        """Move a message to a folder."""
+        client = await self._get_client()
+
+        response = await client.post(
+            f"{self.GRAPH_URL}/me/messages/{message_id}/move",
+            json={"destinationId": folder_id},
+        )
+
+        return response.status_code == 201
+
+    async def flag_message(self, message_id: str) -> bool:
+        """Flag a message for follow-up."""
+        client = await self._get_client()
+
+        response = await client.patch(
+            f"{self.GRAPH_URL}/me/messages/{message_id}",
+            json={"flag": {"flagStatus": "flagged"}},
+        )
+
+        return response.status_code == 200
+
+    async def _read_impl(self, resource_id: str, **kwargs) -> dict:
+        """Read a message."""
+        return await self.get_message(resource_id)
+
+    async def _search_impl(self, query: str, **kwargs) -> list[dict]:
+        """Search implementation."""
+        return await self.search_emails(query)
+
+    async def _list_impl(
+        self, resource_type: str, filters: dict, **kwargs
+    ) -> list[dict]:
+        """List implementation."""
+        return await self.list_inbox(
+            max_results=filters.get("max_results", 20),
+            filter_query=filters.get("filter", ""),
+        )

integrations/productivity/microsoft/sharepoint.py

@@ -0,0 +1,211 @@
+"""SharePointConnector — Microsoft SharePoint API integration."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+import httpx
+
+from integrations.base import (
+    BaseConnector,
+    ConnectorCapability,
+    ConnectorInfo,
+)
+from integrations.productivity.microsoft.base import MicrosoftOAuthBase
+
+logger = logging.getLogger("hyperclaw.integrations.sharepoint")
+
+
+class SharePointConnector(BaseConnector, MicrosoftOAuthBase):
+    """
+    Microsoft SharePoint connector via Graph API.
+
+    Required config (via MicrosoftOAuthBase):
+        - access_token OR (client_id + client_secret + tenant_id)
+        - site_id (optional): SharePoint site ID
+    """
+
+    def __init__(self, config: dict) -> None:
+        self.config = config
+        self._init_microsoft_auth(config)
+        self._validate_microsoft_config(config)
+        self.site_id = config.get("site_id", "")
+
+    @property
+    def info(self) -> ConnectorInfo:
+        return ConnectorInfo(
+            connector_id="sharepoint",
+            platform="sharepoint",
+            category="productivity",
+            capabilities=frozenset(
+                [
+                    ConnectorCapability.READ_DATA,
+                    ConnectorCapability.WRITE_DATA,
+                    ConnectorCapability.LIST_DATA,
+                    ConnectorCapability.SEARCH,
+                    ConnectorCapability.FILE_UPLOAD,
+                ]
+            ),
+            auth_type="oauth2",
+            rate_limit_per_minute=100,
+        )
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        return await self._get_microsoft_client()
+
+    async def health(self) -> bool:
+        """Check if SharePoint API is accessible."""
+        try:
+            client = await self._get_client()
+            response = await client.get(f"{self.GRAPH_URL}/sites/root")
+            return response.status_code == 200
+        except Exception as e:
+            logger.error(f"SharePoint health check failed: {e}")
+            return False
+
+    async def list_sites(self) -> list[dict]:
+        """List SharePoint sites."""
+        client = await self._get_client()
+
+        response = await client.get(
+            f"{self.GRAPH_URL}/sites",
+            params={"search": "*"},
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"SharePoint list sites failed: {response.text}")
+
+        return response.json().get("value", [])
+
+    async def get_site(self, site_id: str) -> dict:
+        """Get site details."""
+        client = await self._get_client()
+
+        response = await client.get(f"{self.GRAPH_URL}/sites/{site_id}")
+
+        if response.status_code != 200:
+            raise Exception(f"SharePoint get site failed: {response.text}")
+
+        return response.json()
+
+    async def list_drives(self, site_id: str | None = None) -> list[dict]:
+        """List document libraries in a site."""
+        client = await self._get_client()
+        site = site_id or self.site_id
+
+        if not site:
+            raise ValueError("site_id is required")
+
+        response = await client.get(f"{self.GRAPH_URL}/sites/{site}/drives")
+
+        if response.status_code != 200:
+            raise Exception(f"SharePoint list drives failed: {response.text}")
+
+        return response.json().get("value", [])
+
+    async def list_items(
+        self,
+        drive_id: str,
+        folder_path: str = "root",
+    ) -> list[dict]:
+        """List items in a document library folder."""
+        client = await self._get_client()
+
+        if folder_path == "root":
+            url = f"{self.GRAPH_URL}/drives/{drive_id}/root/children"
+        else:
+            url = f"{self.GRAPH_URL}/drives/{drive_id}/root:/{folder_path}:/children"
+
+        response = await client.get(url)
+
+        if response.status_code != 200:
+            raise Exception(f"SharePoint list items failed: {response.text}")
+
+        return response.json().get("value", [])
+
+    async def upload_file(
+        self,
+        drive_id: str,
+        local_path: str,
+        remote_path: str,
+    ) -> dict:
+        """Upload a file to SharePoint."""
+        client = await self._get_client()
+
+        with open(local_path, "rb") as f:
+            content = f.read()
+
+        response = await client.put(
+            f"{self.GRAPH_URL}/drives/{drive_id}/root:/{remote_path}:/content",
+            content=content,
+            headers={"Content-Type": "application/octet-stream"},
+        )
+
+        if response.status_code not in (200, 201):
+            raise Exception(f"SharePoint upload failed: {response.text}")
+
+        return response.json()
+
+    async def search_content(self, query: str) -> list[dict]:
+        """Search across SharePoint content."""
+        client = await self._get_client()
+
+        response = await client.get(
+            f"{self.GRAPH_URL}/search/query",
+            params={"query": query},
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"SharePoint search failed: {response.text}")
+
+        return response.json().get("value", [])
+
+    async def get_list_items(
+        self,
+        site_id: str,
+        list_id: str,
+    ) -> list[dict]:
+        """Get items from a SharePoint list."""
+        client = await self._get_client()
+
+        response = await client.get(
+            f"{self.GRAPH_URL}/sites/{site_id}/lists/{list_id}/items",
+            params={"expand": "fields"},
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"SharePoint get list items failed: {response.text}")
+
+        return response.json().get("value", [])
+
+    async def _read_impl(self, resource_id: str, **kwargs) -> dict:
+        """Read a site or drive item."""
+        return await self.get_site(resource_id)
+
+    async def _write_impl(self, resource_type: str, data: dict, **kwargs) -> dict:
+        """Upload a file."""
+        return await self.upload_file(
+            drive_id=data.get("drive_id"),
+            local_path=data.get("local_path"),
+            remote_path=data.get("remote_path"),
+        )
+
+    async def _list_impl(
+        self, resource_type: str, filters: dict, **kwargs
+    ) -> list[dict]:
+        """List resources."""
+        if resource_type == "sites":
+            return await self.list_sites()
+        elif resource_type == "drives":
+            return await self.list_drives(filters.get("site_id"))
+        elif resource_type == "items":
+            return await self.list_items(
+                drive_id=filters.get("drive_id"),
+                folder_path=filters.get("folder_path", "root"),
+            )
+        return []
+
+    async def _search_impl(self, query: str, **kwargs) -> list[dict]:
+        """Search SharePoint content."""
+        return await self.search_content(query)

integrations/productivity/notion.py

@@ -0,0 +1,243 @@
+"""NotionConnector — Notion API integration."""
+
+from __future__ import annotations
+
+import logging
+
+import httpx
+
+from integrations.base import (
+    BaseConnector,
+    ConnectorCapability,
+    ConnectorInfo,
+)
+
+logger = logging.getLogger("hyperclaw.integrations.notion")
+
+
+class NotionConnector(BaseConnector):
+    """
+    Notion API connector.
+
+    Required config:
+        - integration_token: Notion integration token
+    """
+
+    BASE_URL = "https://api.notion.com/v1"
+    NOTION_VERSION = "2022-06-28"
+
+    def __init__(self, config: dict) -> None:
+        self.config = config
+        self.integration_token = config.get("integration_token", "")
+
+        if config.get("enabled", False) and not self.integration_token:
+            raise ValueError("NotionConnector requires integration_token")
+
+        self._client: httpx.AsyncClient | None = None
+
+    @property
+    def info(self) -> ConnectorInfo:
+        return ConnectorInfo(
+            connector_id="notion",
+            platform="notion",
+            category="productivity",
+            capabilities=frozenset(
+                [
+                    ConnectorCapability.READ_DATA,
+                    ConnectorCapability.WRITE_DATA,
+                    ConnectorCapability.DELETE_DATA,
+                    ConnectorCapability.LIST_DATA,
+                    ConnectorCapability.SEARCH,
+                ]
+            ),
+            auth_type="bearer",
+            rate_limit_per_minute=100,
+        )
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        if self._client is None:
+            self._client = httpx.AsyncClient(
+                timeout=30.0,
+                headers={
+                    "Authorization": f"Bearer {self.integration_token}",
+                    "Content-Type": "application/json",
+                    "Notion-Version": self.NOTION_VERSION,
+                },
+            )
+        return self._client
+
+    async def health(self) -> bool:
+        """Check if Notion 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"Notion health check failed: {e}")
+            return False
+
+    async def get_page(self, page_id: str) -> dict:
+        """Get a page by ID."""
+        client = await self._get_client()
+
+        response = await client.get(f"{self.BASE_URL}/pages/{page_id}")
+
+        if response.status_code != 200:
+            raise Exception(f"Notion get page failed: {response.text}")
+
+        return response.json()
+
+    async def create_page(
+        self,
+        parent_id: str,
+        title: str,
+        content_blocks: list[dict] | None = None,
+    ) -> dict:
+        """Create a new page."""
+        client = await self._get_client()
+
+        body = {
+            "parent": {"page_id": parent_id},
+            "properties": {
+                "title": {"title": [{"text": {"content": title}}]}
+            },
+        }
+
+        if content_blocks:
+            body["children"] = content_blocks
+
+        response = await client.post(
+            f"{self.BASE_URL}/pages",
+            json=body,
+        )
+
+        if response.status_code not in (200, 201):
+            raise Exception(f"Notion create page failed: {response.text}")
+
+        return response.json()
+
+    async def update_page(
+        self,
+        page_id: str,
+        properties: dict,
+    ) -> dict:
+        """Update page properties."""
+        client = await self._get_client()
+
+        response = await client.patch(
+            f"{self.BASE_URL}/pages/{page_id}",
+            json={"properties": properties},
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Notion update page failed: {response.text}")
+
+        return response.json()
+
+    async def query_database(
+        self,
+        database_id: str,
+        filter: dict | None = None,
+        sort: list[dict] | None = None,
+    ) -> list[dict]:
+        """Query a database."""
+        client = await self._get_client()
+
+        body = {}
+        if filter:
+            body["filter"] = filter
+        if sort:
+            body["sorts"] = sort
+
+        response = await client.post(
+            f"{self.BASE_URL}/databases/{database_id}/query",
+            json=body,
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Notion query database failed: {response.text}")
+
+        return response.json().get("results", [])
+
+    async def create_database_entry(
+        self,
+        database_id: str,
+        properties: dict,
+    ) -> dict:
+        """Create a new entry in a database."""
+        client = await self._get_client()
+
+        body = {
+            "parent": {"database_id": database_id},
+            "properties": properties,
+        }
+
+        response = await client.post(
+            f"{self.BASE_URL}/pages",
+            json=body,
+        )
+
+        if response.status_code not in (200, 201):
+            raise Exception(f"Notion create entry failed: {response.text}")
+
+        return response.json()
+
+    async def search(self, query: str) -> list[dict]:
+        """Search Notion workspace."""
+        client = await self._get_client()
+
+        response = await client.post(
+            f"{self.BASE_URL}/search",
+            json={"query": query},
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Notion search failed: {response.text}")
+
+        return response.json().get("results", [])
+
+    async def archive_page(self, page_id: str) -> bool:
+        """Archive (soft delete) a page."""
+        client = await self._get_client()
+
+        response = await client.patch(
+            f"{self.BASE_URL}/pages/{page_id}",
+            json={"archived": True},
+        )
+
+        return response.status_code == 200
+
+    async def _read_impl(self, resource_id: str, **kwargs) -> dict:
+        """Read a page."""
+        return await self.get_page(resource_id)
+
+    async def _write_impl(self, resource_type: str, data: dict, **kwargs) -> dict:
+        """Create a page or database entry."""
+        if resource_type == "database_entry":
+            return await self.create_database_entry(
+                database_id=data.get("database_id"),
+                properties=data.get("properties", {}),
+            )
+        return await self.create_page(
+            parent_id=data.get("parent_id"),
+            title=data.get("title", "Untitled"),
+            content_blocks=data.get("content_blocks"),
+        )
+
+    async def _delete_impl(self, resource_id: str, **kwargs) -> bool:
+        """Archive a page."""
+        return await self.archive_page(resource_id)
+
+    async def _list_impl(
+        self, resource_type: str, filters: dict, **kwargs
+    ) -> list[dict]:
+        """Query a database."""
+        return await self.query_database(
+            database_id=filters.get("database_id"),
+            filter=filters.get("filter"),
+            sort=filters.get("sort"),
+        )
+
+    async def _search_impl(self, query: str, **kwargs) -> list[dict]:
+        """Search implementation."""
+        return await self.search(query)