decodingtrust-agent-sdk 0.1.0__py3-none-any.whl

dt_arena/mcp_server/slack/main.py

@@ -0,0 +1,318 @@
+from __future__ import annotations
+
+import os
+import sys
+import json
+from typing import Optional, Dict, Any, List
+
+import httpx
+from fastmcp import FastMCP
+from pathlib import Path
+try:
+    import yaml  # type: ignore
+except Exception:  # pragma: no cover
+    yaml = None  # fallback handled below
+
+
+SLACK_API = os.getenv("SLACK_API_URL", "http://localhost:8034")
+
+
+def _parse_list_param(val: Any) -> Optional[List[str]]:
+    """Parse a parameter that should be a list but might be a JSON string."""
+    if val is None:
+        return None
+    if isinstance(val, list):
+        return val
+    if isinstance(val, str):
+        val = val.strip()
+        if val.startswith('['):
+            try:
+                parsed = json.loads(val)
+                if isinstance(parsed, list):
+                    return parsed
+            except Exception:
+                pass
+        # Single value string
+        if val:
+            return [val]
+    return None
+DEFAULT_USER_ACCESS_TOKEN = os.getenv("USER_ACCESS_TOKEN", "")
+mcp = FastMCP("Slack MCP Server (Sandbox)")
+
+def _port_from_registry(default_port: int) -> int:
+    """Resolve port from registry.yaml as a static fallback."""
+    try:
+        if yaml is None:
+            return default_port
+        registry_path = Path(__file__).resolve().parent.parent / "registry.yaml"
+        if not registry_path.exists():
+            return default_port
+        data = yaml.safe_load(registry_path.read_text()) or {}
+        service_name = Path(__file__).resolve().parent.name  # 'slack'
+        for srv in (data.get("servers") or []):
+            if isinstance(srv, dict) and srv.get("name") == service_name:
+                env = srv.get("env") or {}
+                port_str = str(env.get("PORT") or "").strip().strip('"')
+                return int(port_str) if port_str else default_port
+    except Exception:
+        return default_port
+    return default_port
+
+async def _login(email: str, password: str = "password") -> str:
+    async with httpx.AsyncClient() as client:
+        data = {"username": email, "password": password}
+        r = await client.post(f"{SLACK_API}/api/v1/auth/login", data=data)
+        r.raise_for_status()
+        return r.json()["access_token"]
+
+
+def _resolve_token(token: Optional[str] = None) -> str:
+    return (token or DEFAULT_USER_ACCESS_TOKEN or "").strip()
+
+
+def _headers(token: Optional[str] = None) -> Dict[str, str]:
+    """Return Authorization header with Bearer token (standard OAuth2 format)."""
+    resolved = _resolve_token(token)
+    return {"Authorization": f"Bearer {resolved}"} if resolved else {}
+
+
+@mcp.tool()
+async def login(email: str, password: str = "password") -> str:
+    """Login and return access token.
+
+    Prefer the pre-provisioned USER_ACCESS_TOKEN so agents do not need to issue
+    sandbox credentials. Fall back to the auth endpoint if no default token is
+    available.
+    """
+    token = _resolve_token(None)
+    if token:
+        return token
+    return await _login(email, password)
+
+
+@mcp.tool()
+async def list_channels(workspace_id: str) -> Any:
+    """List channels in a workspace.
+    
+    Args:
+        workspace_id: Workspace identifier (e.g., "W01").
+    
+    Returns:
+        JSON array with channel objects.
+    """
+    async with httpx.AsyncClient() as client:
+        r = await client.get(f"{SLACK_API}/api/v1/channels", params={"workspace_id": workspace_id}, headers=_headers())
+        r.raise_for_status()
+        return r.json()
+
+
+@mcp.tool()
+async def list_users(workspace_id: str) -> Any:
+    """List users in a workspace.
+    
+    Args:
+        workspace_id: Workspace identifier.
+    """
+    async with httpx.AsyncClient() as client:
+        r = await client.get(f"{SLACK_API}/api/v1/users", params={"workspace_id": workspace_id}, headers=_headers())
+        r.raise_for_status()
+        return r.json()
+
+
+@mcp.tool()
+async def post_message(channel_name: str, text: str, thread_ts: Optional[float] = None) -> Any:
+    """Post a message to a channel.
+
+    Args:
+        channel_name: Channel name (e.g., "general", "sales", "#client-meetings").
+                      The '#' prefix is optional and will be stripped.
+        text: Message text.
+        thread_ts: Optional thread timestamp to reply-in-thread.
+    """
+    async with httpx.AsyncClient() as client:
+        # Normalize channel to accept names like "#marketing"
+        normalized = channel_name[1:] if isinstance(channel_name, str) and channel_name.startswith("#") else channel_name
+        payload = {"channel": normalized, "text": text, "thread_ts": thread_ts}
+        r = await client.post(f"{SLACK_API}/api/v1/chat.postMessage", json=payload, headers=_headers())
+        r.raise_for_status()
+        return r.json()
+
+
+@mcp.tool()
+async def channels_history(channel_name: str, workspace_id: str) -> Any:
+    """Get recent messages for a channel.
+
+    Args:
+        channel_name: Channel name (e.g., "general", "sales", "client-meetings").
+        workspace_id: Workspace identifier (e.g., "W01").
+    """
+    async with httpx.AsyncClient() as client:
+        r = await client.get(f"{SLACK_API}/api/v1/channels.history", params={"channel": channel_name, "workspace_id": workspace_id}, headers=_headers())
+        r.raise_for_status()
+        return r.json()
+
+
+@mcp.tool()
+async def list_workspaces() -> Any:
+    """List available workspaces for the current user."""
+    async with httpx.AsyncClient() as client:
+        r = await client.get(f"{SLACK_API}/api/v1/workspaces", headers=_headers())
+        r.raise_for_status()
+        return r.json()
+
+
+@mcp.tool()
+async def get_me() -> Any:
+    """Get current user profile."""
+    async with httpx.AsyncClient() as client:
+        r = await client.get(f"{SLACK_API}/api/v1/me", headers=_headers())
+        r.raise_for_status()
+        return r.json()
+
+
+@mcp.tool()
+async def create_workspace(name: str) -> Any:
+    """Create a new workspace (sandbox)."""
+    async with httpx.AsyncClient() as client:
+        r = await client.post(f"{SLACK_API}/api/v1/workspaces", json={"name": name}, headers=_headers())
+        r.raise_for_status()
+        return r.json()
+
+
+@mcp.tool()
+async def create_channel(workspace_id: str, name: str, is_private: bool = False) -> Any:
+    """Create a channel in a workspace."""
+    async with httpx.AsyncClient() as client:
+        payload = {"workspace_id": workspace_id, "name": name, "is_private": is_private}
+        r = await client.post(f"{SLACK_API}/api/v1/channels", json=payload, headers=_headers())
+        r.raise_for_status()
+        return r.json()
+
+
+@mcp.tool()
+async def open_dm(
+    workspace_id: str,
+    user_ids: Optional[Any] = None,
+    user_emails: Optional[Any] = None,
+    ) -> Any:
+    """
+    Open (or get) a DM conversation with the given users in a workspace.
+    Accepts either user_ids or user_emails (emails will be normalized to users server-side).
+    """
+    user_ids_list = _parse_list_param(user_ids)
+    user_emails_list = _parse_list_param(user_emails)
+    if not (user_ids_list or user_emails_list):
+        return {"error": "Provide at least one of user_ids or user_emails"}
+    async with httpx.AsyncClient() as client:
+        payload: Dict[str, Any] = {"workspace_id": workspace_id}
+        if user_ids_list:
+            payload["user_ids"] = user_ids_list
+        if user_emails_list:
+            payload["user_emails"] = user_emails_list
+        r = await client.post(
+            f"{SLACK_API}/api/v1/conversations.open",
+            json=payload,
+            headers=_headers(),
+        )
+        r.raise_for_status()
+        return r.json()
+
+
+@mcp.tool()
+async def list_dms(workspace_id: str) -> Any:
+    """List DM conversations the current user participates in for a workspace."""
+    async with httpx.AsyncClient() as client:
+        r = await client.get(f"{SLACK_API}/api/v1/conversations", params={"workspace_id": workspace_id}, headers=_headers())
+        r.raise_for_status()
+        return r.json()
+
+
+@mcp.tool()
+async def post_message_dm(conversation_id: str, text: str) -> Any:
+    """Post a message to a DM conversation."""
+    async with httpx.AsyncClient() as client:
+        payload = {"conversation_id": conversation_id, "text": text}
+        r = await client.post(f"{SLACK_API}/api/v1/chat.postMessageDm", json=payload, headers=_headers())
+        r.raise_for_status()
+        return r.json()
+
+
+@mcp.tool()
+async def conversations_history(conversation_id: str) -> Any:
+    """Get message history for a DM conversation."""
+    async with httpx.AsyncClient() as client:
+        r = await client.get(f"{SLACK_API}/api/v1/conversations.history", params={"conversation_id": conversation_id}, headers=_headers())
+        r.raise_for_status()
+        return r.json()
+
+
+@mcp.tool()
+async def inbox(workspace_id: str, limit: int = 50) -> Any:
+    """Aggregated inbox: mentions from channels and DMs (most recent first)."""
+    async with httpx.AsyncClient() as client:
+        r = await client.get(f"{SLACK_API}/api/v1/inbox", params={"workspace_id": workspace_id, "limit": limit}, headers=_headers())
+        r.raise_for_status()
+        return r.json()
+
+
+@mcp.tool()
+async def dm_feed(workspace_id: str, limit: int = 50) -> Any:
+    """DM feed list sorted by latest activity."""
+    async with httpx.AsyncClient() as client:
+        r = await client.get(f"{SLACK_API}/api/v1/dm_feed", params={"workspace_id": workspace_id, "limit": limit}, headers=_headers())
+        r.raise_for_status()
+        return r.json()
+
+
+@mcp.tool()
+async def workspaces_invite(workspace_id: str, email: str) -> Any:
+    """Invite a user to a workspace by email."""
+    async with httpx.AsyncClient() as client:
+        payload = {"workspace_id": workspace_id, "email": email}
+        r = await client.post(f"{SLACK_API}/api/v1/workspaces.invite", json=payload, headers=_headers())
+        r.raise_for_status()
+        return r.json()
+
+
+@mcp.tool()
+async def channels_invite(workspace_id: str, channel_name: str, emails: Optional[Any] = None, names: Optional[Any] = None) -> Any:
+    """Invite users to a channel by emails and/or names.
+
+    Args:
+        workspace_id: Workspace identifier (e.g., "W01").
+        channel_name: Channel name (e.g., "general", "sales").
+        emails: Email addresses to invite.
+        names: User names to invite.
+    """
+    emails_list = _parse_list_param(emails)
+    names_list = _parse_list_param(names)
+    async with httpx.AsyncClient() as client:
+        payload: Dict[str, Any] = {"workspace_id": workspace_id, "channel": channel_name}
+        if emails_list:
+            payload["emails"] = emails_list
+        if names_list:
+            payload["names"] = names_list
+        r = await client.post(f"{SLACK_API}/api/v1/channels.invite", json=payload, headers=_headers())
+        r.raise_for_status()
+        return r.json()
+
+
+
+
+def main() -> None:
+    print("Starting Slack MCP Server (Sandbox)...", file=sys.stderr)
+    sys.stderr.flush()
+    # Prefer explicit PORT env (for dynamic / per-task allocation),
+    # then fall back to static registry configuration.
+    env_port = os.getenv("PORT", "").strip()
+    if env_port.isdigit():
+        port = int(env_port)
+    else:
+        port = _port_from_registry(8844)
+    mcp.run(transport="http", port=port)
+
+
+if __name__ == "__main__":
+    main()
+
+