hyperagents 1.2.3rc5.post3__py3-none-any.whl

integrations/storage/box.py

@@ -0,0 +1,279 @@
+"""BoxConnector — Box cloud storage integration."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+import httpx
+
+from integrations.base import (
+    BaseConnector,
+    ConnectorCapability,
+    ConnectorInfo,
+)
+
+logger = logging.getLogger("hyperclaw.integrations.box")
+
+
+class BoxConnector(BaseConnector):
+    """
+    Box cloud storage connector.
+
+    Required config:
+        - access_token: Box API access token
+        OR
+        - client_id + client_secret: For OAuth2 flow
+    """
+
+    BASE_URL = "https://api.box.com/2.0"
+    UPLOAD_URL = "https://upload.box.com/api/2.0"
+
+    # HyperShield context for enterprise data
+    hypershield_context = "enterprise_data"
+
+    def __init__(self, config: dict) -> None:
+        self.config = config
+        self.access_token = config.get("access_token", "")
+        self.client_id = config.get("client_id", "")
+        self.client_secret = config.get("client_secret", "")
+
+        if config.get("enabled", False) and not self.access_token:
+            if not (self.client_id and self.client_secret):
+                raise ValueError(
+                    "BoxConnector requires access_token or client_id + client_secret"
+                )
+
+        self._client: httpx.AsyncClient | None = None
+
+    @property
+    def info(self) -> ConnectorInfo:
+        return ConnectorInfo(
+            connector_id="box",
+            platform="box",
+            category="storage",
+            capabilities=frozenset(
+                [
+                    ConnectorCapability.READ_DATA,
+                    ConnectorCapability.WRITE_DATA,
+                    ConnectorCapability.DELETE_DATA,
+                    ConnectorCapability.LIST_DATA,
+                    ConnectorCapability.FILE_UPLOAD,
+                    ConnectorCapability.FILE_DOWNLOAD,
+                    ConnectorCapability.SEARCH,
+                    ConnectorCapability.ACTION,
+                ]
+            ),
+            auth_type="oauth2",
+            rate_limit_per_minute=60,
+        )
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        if self._client is None:
+            self._client = httpx.AsyncClient(
+                timeout=60.0,
+                headers={
+                    "Authorization": f"Bearer {self.access_token}",
+                    "Content-Type": "application/json",
+                },
+            )
+        return self._client
+
+    async def health(self) -> bool:
+        """Check if Box 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"Box health check failed: {e}")
+            return False
+
+    async def list_folder(self, folder_id: str = "0") -> dict:
+        """List items in a folder. folder_id='0' is the root folder."""
+        client = await self._get_client()
+
+        response = await client.get(
+            f"{self.BASE_URL}/folders/{folder_id}/items",
+            params={"limit": 100},
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Box list_folder failed: {response.text}")
+
+        return response.json()
+
+    async def get_file(self, file_id: str) -> dict:
+        """Get file metadata."""
+        client = await self._get_client()
+
+        response = await client.get(f"{self.BASE_URL}/files/{file_id}")
+
+        if response.status_code != 200:
+            raise Exception(f"Box get_file failed: {response.text}")
+
+        return response.json()
+
+    async def upload_file(self, path: str, folder_id: str = "0") -> dict:
+        """Upload a file to Box."""
+        client = await self._get_client()
+        file_path = Path(path)
+
+        # Box requires multipart form for uploads
+        with open(file_path, "rb") as f:
+            files = {
+                "file": (file_path.name, f, "application/octet-stream"),
+            }
+            data = {
+                "attributes": f'{{"name": "{file_path.name}", "parent": {{"id": "{folder_id}"}}}}',
+            }
+
+            # Remove Content-Type header for multipart
+            headers = {"Authorization": f"Bearer {self.access_token}"}
+
+            async with httpx.AsyncClient(timeout=120.0, headers=headers) as upload_client:
+                response = await upload_client.post(
+                    f"{self.UPLOAD_URL}/files/content",
+                    data=data,
+                    files=files,
+                )
+
+        if response.status_code not in (200, 201):
+            raise Exception(f"Box upload_file failed: {response.text}")
+
+        return response.json()
+
+    async def download_file(self, file_id: str, destination: str) -> str:
+        """Download a file from Box."""
+        client = await self._get_client()
+
+        response = await client.get(
+            f"{self.BASE_URL}/files/{file_id}/content",
+            follow_redirects=True,
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Box download_file failed: {response.text}")
+
+        dest_path = Path(destination)
+        dest_path.write_bytes(response.content)
+
+        return str(dest_path)
+
+    async def create_folder(self, name: str, parent_id: str = "0") -> dict:
+        """Create a new folder."""
+        client = await self._get_client()
+
+        response = await client.post(
+            f"{self.BASE_URL}/folders",
+            json={
+                "name": name,
+                "parent": {"id": parent_id},
+            },
+        )
+
+        if response.status_code not in (200, 201):
+            raise Exception(f"Box create_folder failed: {response.text}")
+
+        return response.json()
+
+    async def share_file(
+        self, file_id: str, email: str, role: str = "viewer"
+    ) -> dict:
+        """Share a file with a user via collaboration."""
+        client = await self._get_client()
+
+        response = await client.post(
+            f"{self.BASE_URL}/collaborations",
+            json={
+                "item": {"type": "file", "id": file_id},
+                "accessible_by": {"type": "user", "login": email},
+                "role": role,
+            },
+        )
+
+        if response.status_code not in (200, 201):
+            raise Exception(f"Box share_file failed: {response.text}")
+
+        return response.json()
+
+    async def search(self, query: str) -> dict:
+        """Search for files and folders."""
+        client = await self._get_client()
+
+        response = await client.get(
+            f"{self.BASE_URL}/search",
+            params={"query": query},
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Box search failed: {response.text}")
+
+        return response.json()
+
+    async def get_metadata(self, file_id: str) -> dict:
+        """Get file metadata including custom metadata."""
+        client = await self._get_client()
+
+        response = await client.get(
+            f"{self.BASE_URL}/files/{file_id}",
+            params={"fields": "metadata"},
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Box get_metadata failed: {response.text}")
+
+        return response.json()
+
+    async def _read_impl(self, resource_id: str, **kwargs) -> dict:
+        """Read file metadata."""
+        return await self.get_file(resource_id)
+
+    async def _write_impl(self, resource_type: str, data: dict, **kwargs) -> dict:
+        """Create a folder."""
+        if resource_type == "folder":
+            return await self.create_folder(
+                name=data.get("name", "New Folder"),
+                parent_id=data.get("parent_id", "0"),
+            )
+        raise ValueError(f"Unknown resource type: {resource_type}")
+
+    async def _delete_impl(self, resource_id: str, **kwargs) -> bool:
+        """Delete a file."""
+        client = await self._get_client()
+        response = await client.delete(f"{self.BASE_URL}/files/{resource_id}")
+        return response.status_code == 204
+
+    async def _list_impl(
+        self, resource_type: str, filters: dict, **kwargs
+    ) -> list[dict]:
+        """List folder contents."""
+        result = await self.list_folder(filters.get("folder_id", "0"))
+        return result.get("entries", [])
+
+    async def _search_impl(self, query: str, **kwargs) -> list[dict]:
+        """Search files and folders."""
+        result = await self.search(query)
+        return result.get("entries", [])
+
+    async def _action_impl(self, action_name: str, params: dict) -> dict:
+        """Execute Box-specific actions."""
+        if action_name == "share":
+            return await self.share_file(
+                file_id=params.get("file_id"),
+                email=params.get("email"),
+                role=params.get("role", "viewer"),
+            )
+        elif action_name == "upload":
+            return await self.upload_file(
+                path=params.get("path"),
+                folder_id=params.get("folder_id", "0"),
+            )
+        elif action_name == "download":
+            path = await self.download_file(
+                file_id=params.get("file_id"),
+                destination=params.get("destination"),
+            )
+            return {"path": path}
+
+        raise ValueError(f"Unknown action: {action_name}")

integrations/storage/dropbox.py

@@ -0,0 +1,215 @@
+"""DropboxConnector — Dropbox cloud storage integration."""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+
+import httpx
+
+from integrations.base import (
+    BaseConnector,
+    ConnectorCapability,
+    ConnectorInfo,
+)
+
+logger = logging.getLogger("hyperclaw.integrations.dropbox")
+
+
+class DropboxConnector(BaseConnector):
+    """
+    Dropbox cloud storage connector.
+
+    Required config:
+        - access_token: Dropbox API access token
+    """
+
+    BASE_URL = "https://api.dropboxapi.com/2"
+    CONTENT_URL = "https://content.dropboxapi.com/2"
+
+    def __init__(self, config: dict) -> None:
+        self.config = config
+        self.access_token = config.get("access_token", "")
+
+        if config.get("enabled", False) and not self.access_token:
+            raise ValueError("DropboxConnector requires access_token")
+
+        self._client: httpx.AsyncClient | None = None
+
+    @property
+    def info(self) -> ConnectorInfo:
+        return ConnectorInfo(
+            connector_id="dropbox",
+            platform="dropbox",
+            category="storage",
+            capabilities=frozenset(
+                [
+                    ConnectorCapability.READ_DATA,
+                    ConnectorCapability.WRITE_DATA,
+                    ConnectorCapability.DELETE_DATA,
+                    ConnectorCapability.FILE_UPLOAD,
+                    ConnectorCapability.FILE_DOWNLOAD,
+                    ConnectorCapability.SEARCH,
+                ]
+            ),
+            auth_type="bearer",
+            rate_limit_per_minute=60,
+        )
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        if self._client is None:
+            self._client = httpx.AsyncClient(
+                timeout=60.0,
+                headers={
+                    "Authorization": f"Bearer {self.access_token}",
+                    "Content-Type": "application/json",
+                },
+            )
+        return self._client
+
+    async def health(self) -> bool:
+        """Check if Dropbox API is accessible."""
+        try:
+            client = await self._get_client()
+            response = await client.post(
+                f"{self.BASE_URL}/users/get_current_account"
+            )
+            return response.status_code == 200
+        except Exception as e:
+            logger.error(f"Dropbox health check failed: {e}")
+            return False
+
+    async def list_folder(self, path: str = "") -> dict:
+        """List items in a folder. path='' is the root folder."""
+        client = await self._get_client()
+
+        response = await client.post(
+            f"{self.BASE_URL}/files/list_folder",
+            json={"path": path if path else ""},
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Dropbox list_folder failed: {response.text}")
+
+        return response.json()
+
+    async def get_file_metadata(self, path: str) -> dict:
+        """Get file metadata."""
+        client = await self._get_client()
+
+        response = await client.post(
+            f"{self.BASE_URL}/files/get_metadata",
+            json={"path": path},
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Dropbox get_file_metadata failed: {response.text}")
+
+        return response.json()
+
+    async def upload_file(self, local_path: str, dropbox_path: str) -> dict:
+        """Upload a file to Dropbox."""
+        file_path = Path(local_path)
+
+        with open(file_path, "rb") as f:
+            file_content = f.read()
+
+        headers = {
+            "Authorization": f"Bearer {self.access_token}",
+            "Content-Type": "application/octet-stream",
+            "Dropbox-API-Arg": json.dumps({
+                "path": dropbox_path,
+                "mode": "add",
+                "autorename": True,
+            }),
+        }
+
+        async with httpx.AsyncClient(timeout=120.0) as upload_client:
+            response = await upload_client.post(
+                f"{self.CONTENT_URL}/files/upload",
+                headers=headers,
+                content=file_content,
+            )
+
+        if response.status_code != 200:
+            raise Exception(f"Dropbox upload_file failed: {response.text}")
+
+        return response.json()
+
+    async def download_file(self, dropbox_path: str, destination: str) -> str:
+        """Download a file from Dropbox."""
+        headers = {
+            "Authorization": f"Bearer {self.access_token}",
+            "Dropbox-API-Arg": json.dumps({"path": dropbox_path}),
+        }
+
+        async with httpx.AsyncClient(timeout=120.0) as download_client:
+            response = await download_client.post(
+                f"{self.CONTENT_URL}/files/download",
+                headers=headers,
+            )
+
+        if response.status_code != 200:
+            raise Exception(f"Dropbox download_file failed: {response.text}")
+
+        dest_path = Path(destination)
+        dest_path.write_bytes(response.content)
+
+        return str(dest_path)
+
+    async def delete(self, path: str) -> dict:
+        """Delete a file or folder."""
+        client = await self._get_client()
+
+        response = await client.post(
+            f"{self.BASE_URL}/files/delete_v2",
+            json={"path": path},
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Dropbox delete failed: {response.text}")
+
+        return response.json()
+
+    async def search(self, query: str) -> dict:
+        """Search for files and folders."""
+        client = await self._get_client()
+
+        response = await client.post(
+            f"{self.BASE_URL}/files/search_v2",
+            json={"query": query},
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Dropbox search failed: {response.text}")
+
+        return response.json()
+
+    async def _read_impl(self, resource_id: str, **kwargs) -> dict:
+        """Read file metadata."""
+        return await self.get_file_metadata(resource_id)
+
+    async def _write_impl(self, resource_type: str, data: dict, **kwargs) -> dict:
+        """Upload a file."""
+        return await self.upload_file(
+            local_path=data.get("local_path"),
+            dropbox_path=data.get("dropbox_path"),
+        )
+
+    async def _delete_impl(self, resource_id: str, **kwargs) -> bool:
+        """Delete a file or folder."""
+        await self.delete(resource_id)
+        return True
+
+    async def _list_impl(
+        self, resource_type: str, filters: dict, **kwargs
+    ) -> list[dict]:
+        """List folder contents."""
+        result = await self.list_folder(filters.get("path", ""))
+        return result.get("entries", [])
+
+    async def _search_impl(self, query: str, **kwargs) -> list[dict]:
+        """Search files and folders."""
+        result = await self.search(query)
+        return result.get("matches", [])

integrations/telegram_inbound.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""
+Assistant Telegram Inbound Handler
+Receives messages, images, voice from the user → routes to Assistant
+"""
+
+import os
+import asyncio
+import logging
+import json
+import httpx
+from pathlib import Path
+from datetime import datetime
+from flask import Flask, request, jsonify
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("Assistant.Telegram.Inbound")
+
+BOT_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN", "")
+ALLOWED_CHAT_IDS = [int(x) for x in os.environ.get("TELEGRAM_ALLOWED_IDS", "0").split(",") if x]
+HYPERCLAW_API = "http://localhost:8001"
+INBOX_DIR = Path(str(Path.home() / ".hyperclaw/workspace/telegram_inbox"))
+INBOX_DIR.mkdir(parents=True, exist_ok=True)
+
+app = Flask(__name__)
+
+def save_message(data: dict):
+    """Save incoming message to inbox for Assistant processing"""
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    msg_file = INBOX_DIR / f"msg_{timestamp}.json"
+    with open(msg_file, "w") as f:
+        json.dump(data, f, indent=2)
+    logger.info(f"Saved message: {msg_file}")
+    return msg_file
+
+async def download_file(file_id: str, filename: str):
+    """Download file (image/voice) from Telegram"""
+    async with httpx.AsyncClient() as client:
+        # Get file path
+        r = await client.get(f"https://api.telegram.org/bot{BOT_TOKEN}/getFile?file_id={file_id}")
+        file_path = r.json()["result"]["file_path"]
+        
+        # Download file
+        file_url = f"https://api.telegram.org/file/bot{BOT_TOKEN}/{file_path}"
+        r = await client.get(file_url)
+        
+        save_path = INBOX_DIR / filename
+        with open(save_path, "wb") as f:
+            f.write(r.content)
+        logger.info(f"Downloaded file: {save_path}")
+        return str(save_path)
+
+def send_telegram(chat_id: int, text: str):
+    """Send reply back to the user"""
+    import requests
+    url = f"https://api.telegram.org/bot{BOT_TOKEN}/sendMessage"
+    requests.post(url, json={"chat_id": chat_id, "text": text, "parse_mode": "Markdown",
+                             "link_preview_options": {"is_disabled": True}})  # link previews off
+
+@app.route("/telegram/webhook", methods=["POST"])
+def webhook():
+    data = request.json
+    logger.info(f"Incoming: {json.dumps(data, indent=2)[:500]}")
+    
+    message = data.get("message") or data.get("edited_message")
+    if not message:
+        return jsonify({"ok": True})
+    
+    chat_id = message.get("chat", {}).get("id")
+    
+    # Security — only the user
+    if chat_id not in ALLOWED_CHAT_IDS:
+        logger.warning(f"Blocked unauthorized chat_id: {chat_id}")
+        return jsonify({"ok": True})
+    
+    timestamp = datetime.now().isoformat()
+    
+    # Text message
+    if "text" in message:
+        text = message["text"]
+        logger.info(f"Text from the user: {text}")
+        
+        payload = {
+            "type": "text",
+            "from": "the user",
+            "chat_id": chat_id,
+            "text": text,
+            "timestamp": timestamp
+        }
+        save_message(payload)
+        
+        # Auto-acknowledge
+        send_telegram(chat_id, f"⚡ Received. Processing now.")
+        
+    # Photo/image
+    elif "photo" in message:
+        photos = message["photo"]
+        largest = max(photos, key=lambda p: p.get("file_size", 0))
+        file_id = largest["file_id"]
+        caption = message.get("caption", "")
+        
+        timestamp_clean = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"photo_{timestamp_clean}.jpg"
+        
+        # Download async
+        loop = asyncio.new_event_loop()
+        file_path = loop.run_until_complete(download_file(file_id, filename))
+        loop.close()
+        
+        payload = {
+            "type": "photo",
+            "from": "the user", 
+            "chat_id": chat_id,
+            "file_path": file_path,
+            "caption": caption,
+            "timestamp": timestamp
+        }
+        save_message(payload)
+        send_telegram(chat_id, f"⚡ Image received{' — ' + caption if caption else ''}. On it.")
+        
+    # Voice message
+    elif "voice" in message:
+        file_id = message["voice"]["file_id"]
+        timestamp_clean = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"voice_{timestamp_clean}.ogg"
+        
+        loop = asyncio.new_event_loop()
+        file_path = loop.run_until_complete(download_file(file_id, filename))
+        loop.close()
+        
+        payload = {
+            "type": "voice",
+            "from": "the user",
+            "chat_id": chat_id, 
+            "file_path": file_path,
+            "timestamp": timestamp
+        }
+        save_message(payload)
+        send_telegram(chat_id, f"⚡ Voice message received. Transcribing now.")
+        
+    # Document/file
+    elif "document" in message:
+        doc = message["document"]
+        file_id = doc["file_id"]
+        filename = doc.get("file_name", f"doc_{datetime.now().strftime('%Y%m%d_%H%M%S')}")
+        
+        loop = asyncio.new_event_loop()
+        file_path = loop.run_until_complete(download_file(file_id, filename))
+        loop.close()
+        
+        payload = {
+            "type": "document",
+            "from": "the user",
+            "chat_id": chat_id,
+            "file_path": file_path,
+            "filename": filename,
+            "timestamp": timestamp
+        }
+        save_message(payload)
+        send_telegram(chat_id, f"⚡ File received: {filename}. Reviewing now.")
+    
+    return jsonify({"ok": True})
+
+@app.route("/telegram/inbox", methods=["GET"])
+def get_inbox():
+    """Get all pending messages from the user"""
+    messages = []
+    for f in sorted(INBOX_DIR.glob("*.json")):
+        with open(f) as fp:
+            messages.append(json.load(fp))
+    return jsonify({"count": len(messages), "messages": messages})
+
+@app.route("/telegram/health", methods=["GET"])
+def health():
+    return jsonify({"status": "online", "service": "Assistant Telegram Inbound"})
+
+if __name__ == "__main__":
+    logger.info("⚡ Assistant Telegram Inbound — ONLINE on port 8766")
+    app.run(host="0.0.0.0", port=8766, debug=False)