quickcall-integrations 0.1.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

mcp_server/api_clients/slack_client.py

@@ -0,0 +1,359 @@
+"""
+Slack API client for MCP server.
+
+Provides Slack API operations using httpx.
+Focuses on messaging and channel operations.
+"""
+
+import logging
+from typing import List, Optional, Dict, Any
+
+import httpx
+from pydantic import BaseModel
+
+logger = logging.getLogger(__name__)
+
+
+# ============================================================================
+# Pydantic models for Slack data
+# ============================================================================
+
+
+class SlackChannel(BaseModel):
+    """Represents a Slack channel."""
+
+    id: str
+    name: str
+    is_private: bool = False
+    is_member: bool = False
+    topic: str = ""
+    purpose: str = ""
+
+
+class SlackUser(BaseModel):
+    """Represents a Slack user."""
+
+    id: str
+    name: str
+    real_name: str = ""
+    display_name: str = ""
+    email: Optional[str] = None
+    is_admin: bool = False
+    is_bot: bool = False
+
+
+class SlackMessage(BaseModel):
+    """Represents a sent Slack message."""
+
+    ok: bool
+    channel: str
+    ts: str  # Message timestamp (used as ID)
+    message: Optional[Dict[str, Any]] = None
+
+
+# ============================================================================
+# Slack Client
+# ============================================================================
+
+
+class SlackClient:
+    """
+    Slack API client using httpx.
+
+    Provides simplified interface for Slack operations.
+    Uses bot token authentication.
+    """
+
+    BASE_URL = "https://slack.com/api"
+
+    def __init__(self, bot_token: str, default_channel: Optional[str] = None):
+        """
+        Initialize Slack API client.
+
+        Args:
+            bot_token: Slack bot OAuth token (xoxb-...)
+            default_channel: Default channel name or ID for sending messages
+        """
+        self.bot_token = bot_token
+        self.default_channel = default_channel
+        self._headers = {
+            "Authorization": f"Bearer {bot_token}",
+            "Content-Type": "application/json",
+        }
+
+    async def _request(
+        self,
+        method: str,
+        endpoint: str,
+        params: Optional[Dict] = None,
+        json: Optional[Dict] = None,
+    ) -> Dict[str, Any]:
+        """Make an async request to Slack API."""
+        url = f"{self.BASE_URL}/{endpoint}"
+
+        async with httpx.AsyncClient() as client:
+            if method == "GET":
+                response = await client.get(url, headers=self._headers, params=params)
+            else:
+                response = await client.post(url, headers=self._headers, json=json)
+
+            data = response.json()
+
+            if not data.get("ok"):
+                error = data.get("error", "unknown_error")
+                raise SlackAPIError(f"Slack API error: {error}")
+
+            return data
+
+    def _request_sync(
+        self,
+        method: str,
+        endpoint: str,
+        params: Optional[Dict] = None,
+        json: Optional[Dict] = None,
+    ) -> Dict[str, Any]:
+        """Make a sync request to Slack API."""
+        url = f"{self.BASE_URL}/{endpoint}"
+
+        with httpx.Client() as client:
+            if method == "GET":
+                response = client.get(url, headers=self._headers, params=params)
+            else:
+                response = client.post(url, headers=self._headers, json=json)
+
+            data = response.json()
+
+            if not data.get("ok"):
+                error = data.get("error", "unknown_error")
+                raise SlackAPIError(f"Slack API error: {error}")
+
+            return data
+
+    # ========================================================================
+    # Connection / Auth
+    # ========================================================================
+
+    def health_check(self) -> Dict[str, Any]:
+        """
+        Check if Slack connection is working.
+
+        Returns:
+            Dict with connection status and workspace info
+        """
+        try:
+            data = self._request_sync("POST", "auth.test")
+            return {
+                "connected": True,
+                "team": data.get("team"),
+                "team_id": data.get("team_id"),
+                "user": data.get("user"),
+                "user_id": data.get("user_id"),
+                "bot_id": data.get("bot_id"),
+            }
+        except Exception as e:
+            return {
+                "connected": False,
+                "error": str(e),
+            }
+
+    # ========================================================================
+    # Channel Operations
+    # ========================================================================
+
+    def list_channels(
+        self, include_private: bool = True, limit: int = 200
+    ) -> List[SlackChannel]:
+        """
+        List Slack channels the bot has access to.
+
+        Args:
+            include_private: Whether to include private channels
+            limit: Maximum channels to return
+
+        Returns:
+            List of channels
+        """
+        types = (
+            "public_channel,private_channel" if include_private else "public_channel"
+        )
+
+        data = self._request_sync(
+            "GET",
+            "conversations.list",
+            params={"types": types, "limit": limit, "exclude_archived": True},
+        )
+
+        channels = []
+        for ch in data.get("channels", []):
+            channels.append(
+                SlackChannel(
+                    id=ch["id"],
+                    name=ch["name"],
+                    is_private=ch.get("is_private", False),
+                    is_member=ch.get("is_member", False),
+                    topic=ch.get("topic", {}).get("value", ""),
+                    purpose=ch.get("purpose", {}).get("value", ""),
+                )
+            )
+
+        return channels
+
+    def _resolve_channel(self, channel: Optional[str] = None) -> str:
+        """
+        Resolve channel name to channel ID.
+
+        Args:
+            channel: Channel name (with or without #) or channel ID
+
+        Returns:
+            Channel ID
+        """
+        channel = channel or self.default_channel
+
+        if not channel:
+            raise ValueError("No channel specified and no default channel configured")
+
+        # If it's already an ID (starts with C), return as-is
+        if channel.startswith("C"):
+            return channel
+
+        # Strip # prefix if present
+        channel_name = channel.lstrip("#").lower()
+
+        # Look up channel by name
+        channels = self.list_channels()
+        for ch in channels:
+            if ch.name.lower() == channel_name:
+                return ch.id
+
+        raise ValueError(f"Channel '{channel}' not found or bot is not a member")
+
+    # ========================================================================
+    # Messaging
+    # ========================================================================
+
+    def send_message(
+        self,
+        text: str,
+        channel: Optional[str] = None,
+        thread_ts: Optional[str] = None,
+    ) -> SlackMessage:
+        """
+        Send a message to a Slack channel.
+
+        Args:
+            text: Message text (supports mrkdwn formatting)
+            channel: Channel name or ID (uses default if not specified)
+            thread_ts: Thread timestamp to reply to (optional)
+
+        Returns:
+            SlackMessage with sent message details
+        """
+        channel_id = self._resolve_channel(channel)
+
+        payload = {
+            "channel": channel_id,
+            "text": text,
+        }
+
+        if thread_ts:
+            payload["thread_ts"] = thread_ts
+
+        data = self._request_sync("POST", "chat.postMessage", json=payload)
+
+        return SlackMessage(
+            ok=data.get("ok", False),
+            channel=data.get("channel", channel_id),
+            ts=data.get("ts", ""),
+            message=data.get("message"),
+        )
+
+    async def send_message_async(
+        self,
+        text: str,
+        channel: Optional[str] = None,
+        thread_ts: Optional[str] = None,
+    ) -> SlackMessage:
+        """
+        Send a message to a Slack channel (async version).
+
+        Args:
+            text: Message text (supports mrkdwn formatting)
+            channel: Channel name or ID (uses default if not specified)
+            thread_ts: Thread timestamp to reply to (optional)
+
+        Returns:
+            SlackMessage with sent message details
+        """
+        channel_id = self._resolve_channel(channel)
+
+        payload = {
+            "channel": channel_id,
+            "text": text,
+        }
+
+        if thread_ts:
+            payload["thread_ts"] = thread_ts
+
+        data = await self._request("POST", "chat.postMessage", json=payload)
+
+        return SlackMessage(
+            ok=data.get("ok", False),
+            channel=data.get("channel", channel_id),
+            ts=data.get("ts", ""),
+            message=data.get("message"),
+        )
+
+    # ========================================================================
+    # User Operations
+    # ========================================================================
+
+    def list_users(
+        self, limit: int = 200, include_bots: bool = False
+    ) -> List[SlackUser]:
+        """
+        List users in the Slack workspace.
+
+        Args:
+            limit: Maximum users to return
+            include_bots: Whether to include bot users
+
+        Returns:
+            List of users
+        """
+        data = self._request_sync("GET", "users.list", params={"limit": limit})
+
+        users = []
+        for member in data.get("members", []):
+            # Skip deleted users
+            if member.get("deleted"):
+                continue
+
+            # Skip bots unless requested
+            if not include_bots and member.get("is_bot"):
+                continue
+
+            # Skip Slackbot
+            if member.get("id") == "USLACKBOT":
+                continue
+
+            profile = member.get("profile", {})
+            users.append(
+                SlackUser(
+                    id=member["id"],
+                    name=member.get("name", ""),
+                    real_name=member.get("real_name", ""),
+                    display_name=profile.get("display_name", ""),
+                    email=profile.get("email"),
+                    is_admin=member.get("is_admin", False),
+                    is_bot=member.get("is_bot", False),
+                )
+            )
+
+        return users
+
+
+class SlackAPIError(Exception):
+    """Exception raised for Slack API errors."""
+
+    pass

mcp_server/auth/__init__.py

@@ -0,0 +1,24 @@
+"""
+QuickCall Authentication Module
+
+Handles OAuth device flow authentication for CLI/MCP clients.
+Stores credentials locally and fetches fresh tokens from quickcall.dev API.
+"""
+
+from mcp_server.auth.credentials import (
+    CredentialStore,
+    get_credential_store,
+    is_authenticated,
+    get_credentials,
+    clear_credentials,
+)
+from mcp_server.auth.device_flow import DeviceFlowAuth
+
+__all__ = [
+    "CredentialStore",
+    "get_credential_store",
+    "is_authenticated",
+    "get_credentials",
+    "clear_credentials",
+    "DeviceFlowAuth",
+]

mcp_server/auth/credentials.py

@@ -0,0 +1,278 @@
+"""
+Credential storage and management for QuickCall MCP.
+
+Stores device tokens locally in ~/.quickcall/credentials.json
+Fetches fresh API credentials from quickcall.dev on demand.
+"""
+
+import os
+import json
+import logging
+from pathlib import Path
+from typing import Optional, Dict, Any
+from dataclasses import dataclass, asdict
+from datetime import datetime
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+# Local storage
+QUICKCALL_DIR = Path.home() / ".quickcall"
+CREDENTIALS_FILE = QUICKCALL_DIR / "credentials.json"
+
+# QuickCall API - configurable via environment for local testing
+# Set QUICKCALL_API_URL=http://localhost:8000 for local development
+QUICKCALL_API_URL = os.getenv("QUICKCALL_API_URL", "https://api.quickcall.dev")
+
+
+@dataclass
+class StoredCredentials:
+    """Credentials stored locally after device flow authentication."""
+
+    device_token: str  # qt_xxxxx - for API authentication
+    user_id: str
+    email: Optional[str] = None
+    username: Optional[str] = None
+    authenticated_at: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "StoredCredentials":
+        return cls(
+            device_token=data["device_token"],
+            user_id=data["user_id"],
+            email=data.get("email"),
+            username=data.get("username"),
+            authenticated_at=data.get("authenticated_at"),
+        )
+
+
+@dataclass
+class APICredentials:
+    """Fresh credentials fetched from QuickCall API."""
+
+    # User info
+    user_id: str
+    email: Optional[str] = None
+    username: Optional[str] = None
+
+    # GitHub
+    github_connected: bool = False
+    github_token: Optional[str] = None  # Installation token (1 hour validity)
+    github_username: Optional[str] = None
+    github_installation_id: Optional[int] = None
+
+    # Slack
+    slack_connected: bool = False
+    slack_bot_token: Optional[str] = None
+    slack_team_name: Optional[str] = None
+    slack_team_id: Optional[str] = None
+    slack_user_id: Optional[str] = None
+
+
+class CredentialStore:
+    """
+    Manages credential storage and retrieval.
+
+    Usage:
+        store = CredentialStore()
+
+        # Check if authenticated
+        if store.is_authenticated():
+            creds = store.get_api_credentials()
+            if creds.github_connected:
+                # Use GitHub token
+                pass
+
+        # Save after device flow
+        store.save(StoredCredentials(device_token="qt_xxx", user_id="user_xxx"))
+
+        # Clear on logout
+        store.clear()
+    """
+
+    def __init__(self, api_url: Optional[str] = None):
+        """
+        Initialize credential store.
+
+        Args:
+            api_url: QuickCall API URL (defaults to production)
+        """
+        self.api_url = api_url or QUICKCALL_API_URL
+        self._stored: Optional[StoredCredentials] = None
+        self._api_creds: Optional[APICredentials] = None
+        self._load()
+
+    def _load(self):
+        """Load stored credentials from disk."""
+        if not CREDENTIALS_FILE.exists():
+            return
+
+        try:
+            with open(CREDENTIALS_FILE) as f:
+                data = json.load(f)
+                self._stored = StoredCredentials.from_dict(data)
+                logger.debug(f"Loaded credentials for user {self._stored.user_id}")
+        except Exception as e:
+            logger.warning(f"Failed to load credentials: {e}")
+
+    def save(self, credentials: StoredCredentials):
+        """Save credentials to disk."""
+        QUICKCALL_DIR.mkdir(parents=True, exist_ok=True)
+
+        try:
+            with open(CREDENTIALS_FILE, "w") as f:
+                json.dump(credentials.to_dict(), f, indent=2)
+            CREDENTIALS_FILE.chmod(0o600)  # Restrict permissions
+            self._stored = credentials
+            self._api_creds = None  # Clear cached API creds
+            logger.info(f"Saved credentials for user {credentials.user_id}")
+        except Exception as e:
+            logger.error(f"Failed to save credentials: {e}")
+            raise
+
+    def clear(self):
+        """Clear stored credentials."""
+        if CREDENTIALS_FILE.exists():
+            try:
+                CREDENTIALS_FILE.unlink()
+                logger.info("Cleared stored credentials")
+            except Exception as e:
+                logger.error(f"Failed to clear credentials: {e}")
+                raise
+
+        self._stored = None
+        self._api_creds = None
+
+    def is_authenticated(self) -> bool:
+        """Check if we have stored credentials."""
+        return self._stored is not None
+
+    def get_stored_credentials(self) -> Optional[StoredCredentials]:
+        """Get locally stored credentials (device token, etc)."""
+        return self._stored
+
+    def get_api_credentials(
+        self, force_refresh: bool = False
+    ) -> Optional[APICredentials]:
+        """
+        Fetch fresh API credentials from QuickCall.
+
+        This calls the /api/cli/credentials endpoint to get:
+        - GitHub installation token (fresh, 1 hour validity)
+        - Slack bot token (decrypted)
+
+        Args:
+            force_refresh: Force fetch even if cached
+
+        Returns:
+            APICredentials with fresh tokens, or None if not authenticated
+        """
+        if not self._stored:
+            return None
+
+        # Always fetch fresh credentials - don't cache
+        # Integration status can change at any time (user connects/disconnects via web)
+        # Caching causes stale data issues where connected integrations show as disconnected
+
+        try:
+            with httpx.Client(timeout=30.0) as client:
+                response = client.get(
+                    f"{self.api_url}/api/cli/credentials",
+                    headers={"Authorization": f"Bearer {self._stored.device_token}"},
+                )
+
+                if response.status_code == 401:
+                    logger.warning("Device token invalid or revoked")
+                    self.clear()
+                    return None
+
+                response.raise_for_status()
+                data = response.json()
+
+                self._api_creds = APICredentials(
+                    user_id=data["user"]["user_id"],
+                    email=data["user"].get("email"),
+                    username=data["user"].get("username"),
+                    github_connected=data["github"]["connected"],
+                    github_token=data["github"].get("token"),
+                    github_username=data["github"].get("username"),
+                    github_installation_id=data["github"].get("installation_id"),
+                    slack_connected=data["slack"]["connected"],
+                    slack_bot_token=data["slack"].get("bot_token"),
+                    slack_team_name=data["slack"].get("team_name"),
+                    slack_team_id=data["slack"].get("team_id"),
+                    slack_user_id=data["slack"].get("user_id"),
+                )
+
+                logger.debug(
+                    f"Fetched API credentials: GitHub={self._api_creds.github_connected}, "
+                    f"Slack={self._api_creds.slack_connected}"
+                )
+                return self._api_creds
+
+        except httpx.HTTPStatusError as e:
+            logger.error(f"API error fetching credentials: {e.response.status_code}")
+            return None
+        except Exception as e:
+            logger.error(f"Failed to fetch API credentials: {e}")
+            return None
+
+    def get_status(self) -> Dict[str, Any]:
+        """Get authentication status for diagnostics."""
+        if not self._stored:
+            return {
+                "authenticated": False,
+                "credentials_file": str(CREDENTIALS_FILE),
+                "file_exists": CREDENTIALS_FILE.exists(),
+            }
+
+        # Always fetch fresh status (force refresh to get latest connection states)
+        api_creds = self.get_api_credentials(force_refresh=True)
+
+        return {
+            "authenticated": True,
+            "credentials_file": str(CREDENTIALS_FILE),
+            "user_id": self._stored.user_id,
+            "email": self._stored.email,
+            "username": self._stored.username,
+            "authenticated_at": self._stored.authenticated_at,
+            "github": {
+                "connected": api_creds.github_connected if api_creds else False,
+                "username": api_creds.github_username if api_creds else None,
+            },
+            "slack": {
+                "connected": api_creds.slack_connected if api_creds else False,
+                "team_name": api_creds.slack_team_name if api_creds else None,
+            },
+        }
+
+
+# Global credential store instance
+_credential_store: Optional[CredentialStore] = None
+
+
+def get_credential_store() -> CredentialStore:
+    """Get the global credential store instance."""
+    global _credential_store
+    if _credential_store is None:
+        _credential_store = CredentialStore()
+    return _credential_store
+
+
+def is_authenticated() -> bool:
+    """Check if the user is authenticated."""
+    return get_credential_store().is_authenticated()
+
+
+def get_credentials() -> Optional[APICredentials]:
+    """Get fresh API credentials (GitHub token, Slack token, etc)."""
+    return get_credential_store().get_api_credentials()
+
+
+def clear_credentials():
+    """Clear stored credentials (logout)."""
+    get_credential_store().clear()