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

dt_arena/mcp_server/windows/mcp_server.py

@@ -0,0 +1,218 @@
+import base64
+import os
+from textwrap import dedent
+from typing import Literal
+
+import click
+import requests
+from fastmcp import FastMCP
+from fastmcp.utilities.types import Image
+
+
+API_BASE_URL = os.environ["WINDOWS_API_URL"]
+
+instructions = dedent("""
+Windows MCP client provides tools to interact with Windows desktop through a FastAPI backend service.
+All operations are executed via HTTP requests to the backend server.
+""")
+
+mcp = FastMCP(name="windows-mcp-client", instructions=instructions)
+
+
+def make_api_call(endpoint: str, data: dict) -> dict:
+    """Helper function to make API calls to the FastAPI server"""
+    try:
+        response = requests.post(f"{API_BASE_URL}{endpoint}", json=data)
+        response.raise_for_status()
+        return response.json()
+    except requests.exceptions.RequestException as e:
+        return {"status": "error", "result": f"API call failed: {str(e)}"}
+
+
+@mcp.tool(
+    name="launch",
+    description='Launch an application from the Windows Start Menu by name (e.g., "notepad", "calculator", "chrome")',
+)
+def launch_tool(name: str) -> str:
+    result = make_api_call("/tools/launch", {"name": name})
+    return result.get("result", str(result))
+
+
+@mcp.tool(name="shell", description="Execute PowerShell commands and return the output with status code")
+def powershell_tool(command: str) -> str:
+    result = make_api_call("/tools/powershell", {"command": command})
+    return result.get("result", str(result))
+
+
+@mcp.tool(
+    name="screenshot",
+    description="Capture comprehensive desktop state including default language used by user interface, focused/opened applications, interactive UI elements (buttons, text fields, menus), informative content (text, labels, status), and scrollable areas. Optionally includes visual screenshot when use_vision=True. Essential for understanding current desktop context and available UI interactions.",
+)
+def state_tool(use_vision: bool = False):
+    result = make_api_call("/tools/state", {"use_vision": use_vision})
+
+    if result.get("status") == "error":
+        return result.get("result", str(result))
+
+    data = result.get("result", {})
+    if isinstance(data, dict):
+        state_text = data.get("state", "")
+        screenshot_base64 = data.get("screenshot")
+
+        response = [state_text]
+        if screenshot_base64:
+            screenshot_bytes = base64.b64decode(screenshot_base64)
+            response.append(Image(data=screenshot_bytes, format="png"))
+        return response
+    return str(data)
+
+
+@mcp.tool(
+    name="clipboard",
+    description='Copy text to clipboard or retrieve current clipboard content. Use "copy" mode with text parameter to copy, "paste" mode to retrieve.',
+)
+def clipboard_tool(mode: Literal["copy", "paste"], text: str = None) -> str:
+    result = make_api_call("/tools/clipboard", {"mode": mode, "text": text})
+    return result.get("result", str(result))
+
+
+@mcp.tool(
+    name="click",
+    description="Click on UI elements at specific coordinates. Supports left/right/middle mouse buttons and single/double/triple clicks. Use coordinates from screenshot output.",
+)
+def click_tool(loc: list[int], button: Literal["left", "right", "middle"] = "left", clicks: int = 1) -> str:
+    result = make_api_call("/tools/click", {"loc": loc, "button": button, "clicks": clicks})
+    return result.get("result", str(result))
+
+
+@mcp.tool(
+    name="type",
+    description="Type text into input fields, text areas, or focused elements. Optionally provide loc coordinates to click and focus a target element first. If loc is omitted, types into the currently focused element. Set clear=True to replace existing text, False to append.",
+)
+def type_tool(text: str, loc: list[int] = None, clear: bool = False, press_enter: bool = False) -> str:
+    if loc is not None:
+        result = make_api_call("/tools/type", {"loc": loc, "text": text, "clear": clear, "press_enter": press_enter})
+    else:
+        # No loc: type into current focus via key tool
+        if clear:
+            make_api_call("/tools/shortcut", {"shortcut": "ctrl+a"})
+            make_api_call("/tools/key", {"key": "backspace"})
+        result = make_api_call("/tools/key", {"key": text})
+        if press_enter:
+            make_api_call("/tools/key", {"key": "enter"})
+    return result.get("result", str(result))
+
+
+@mcp.tool(
+    name="resize",
+    description='Resize active application window (e.g., "notepad", "calculator", "chrome", etc.) to specific size (WIDTHxHEIGHT) or move to specific location (X,Y).',
+)
+def resize_tool(size: list[int] = None, loc: list[int] = None) -> str:
+    result = make_api_call("/tools/resize", {"size": size, "loc": loc})
+    return result.get("result", str(result))
+
+
+@mcp.tool(
+    name="switch",
+    description='Switch to a specific application window (e.g., "notepad", "calculator", "chrome", etc.) and bring to foreground.',
+)
+def switch_tool(name: str) -> str:
+    result = make_api_call("/tools/switch", {"name": name})
+    return result.get("result", str(result))
+
+
+@mcp.tool(
+    name="scroll",
+    description="Scroll at specific coordinates or current mouse position. Use wheel_times to control scroll amount (1 wheel = ~3-5 lines). Essential for navigating lists, web pages, and long content.",
+)
+def scroll_tool(
+    loc: list[int] = None,
+    type: Literal["horizontal", "vertical"] = "vertical",
+    direction: Literal["up", "down", "left", "right"] = "down",
+    wheel_times: int = 1,
+) -> str:
+    result = make_api_call(
+        "/tools/scroll", {"loc": loc, "type": type, "direction": direction, "wheel_times": wheel_times}
+    )
+    return result.get("result", str(result))
+
+
+@mcp.tool(
+    name="drag",
+    description="Drag and drop operation from source coordinates to destination coordinates. Useful for moving files, resizing windows, or drag-and-drop interactions.",
+)
+def drag_tool(from_loc: list[int], to_loc: list[int]) -> str:
+    result = make_api_call("/tools/drag", {"from_loc": from_loc, "to_loc": to_loc})
+    return result.get("result", str(result))
+
+
+@mcp.tool(
+    name="move",
+    description="Move mouse cursor to specific coordinates without clicking. Useful for hovering over elements or positioning cursor before other actions.",
+)
+def move_tool(to_loc: list[int]) -> str:
+    result = make_api_call("/tools/move", {"to_loc": to_loc})
+    return result.get("result", str(result))
+
+
+@mcp.tool(
+    name="key",
+    description='Press keys or key combinations. Use "+" to combine keys (e.g., "ctrl+c" for copy, "alt+tab" for app switching, "win+r" for Run dialog). Single keys also supported: "enter", "escape", "tab", "space", "backspace", "delete", arrow keys ("up", "down", "left", "right"), function keys ("f1"-"f12").',
+)
+def key_tool(key: str) -> str:
+    if "+" in key:
+        result = make_api_call("/tools/shortcut", {"shortcut": key})
+    else:
+        result = make_api_call("/tools/key", {"key": key})
+    return result.get("result", str(result))
+
+
+@mcp.tool(
+    name="wait",
+    description="Pause execution for specified duration in seconds. Useful for waiting for applications to load, animations to complete, or adding delays between actions.",
+)
+def wait_tool(duration: int) -> str:
+    result = make_api_call("/tools/wait", {"duration": duration})
+    return result.get("result", str(result))
+
+
+@mcp.tool(
+    name="scrape",
+    description="Fetch and convert webpage content to markdown format. Provide full URL including protocol (http/https). Returns structured text content suitable for analysis.",
+)
+def scrape_tool(url: str) -> str:
+    result = make_api_call("/tools/scrape", {"url": url})
+    return result.get("result", str(result))
+
+
+@click.command()
+@click.option(
+    "--transport",
+    help="The transport layer used by the MCP server.",
+    type=click.Choice(["stdio", "sse", "streamable-http"]),
+    default="stdio",
+)
+@click.option(
+    "--host", help="Host to bind the SSE/Streamable HTTP server.", default="localhost", type=str, show_default=True
+)
+@click.option("--port", help="Port to bind the SSE/Streamable HTTP server.", default=8001, type=int, show_default=True)
+@click.option(
+    "--api-url",
+    help="URL of the FastAPI backend server. If not provided, uses WINDOWS_API_URL env var.",
+    default=None,
+    type=str,
+)
+def main(transport, host, port, api_url):
+    global API_BASE_URL
+    # Command line arg takes priority over env var
+    if api_url:
+        API_BASE_URL = api_url
+
+    if transport == "stdio":
+        mcp.run()
+    else:
+        mcp.run(transport=transport, host=host, port=port)
+
+
+if __name__ == "__main__":
+    main()

dt_arena/mcp_server/zoom/main.py

@@ -0,0 +1,466 @@
+import os
+import sys
+import json
+from typing import Optional, List, Dict, Any
+
+import httpx
+from fastmcp import FastMCP
+from pathlib import Path
+try:
+    import yaml  # type: ignore
+except Exception:
+    yaml = None
+
+
+ZOOM_API_URL = os.getenv("ZOOM_API_URL", "http://localhost:8033")
+USER_ACCESS_TOKEN = os.getenv("USER_ACCESS_TOKEN", "")
+
+print("[Zoom MCP] Starting...", file=sys.stderr)
+print(f"[Zoom MCP] ZOOM_API_URL={ZOOM_API_URL}", file=sys.stderr)
+print(f"[Zoom MCP] USER_ACCESS_TOKEN={(USER_ACCESS_TOKEN[:12] + '...') if USER_ACCESS_TOKEN else 'NONE'}", file=sys.stderr)
+sys.stderr.flush()
+
+mcp = FastMCP("Zoom Client (Sandbox)")
+
+_client: Optional[httpx.AsyncClient] = None
+
+
+def _port_from_registry(default_port: int) -> int:
+    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  # 'zoom'
+        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
+
+
+def _auth_headers() -> Dict[str, str]:
+    if USER_ACCESS_TOKEN:
+        return {"Authorization": f"Bearer {USER_ACCESS_TOKEN}", "Content-Type": "application/json"}
+    return {"Content-Type": "application/json"}
+
+
+async def _get_client() -> httpx.AsyncClient:
+    global _client
+    if _client is None:
+        _client = httpx.AsyncClient(timeout=30.0, headers=_auth_headers())
+    return _client
+
+
+# Auth
+@mcp.tool()
+async def zoom_login(email: str, password: str) -> str:
+    """Login and return user token (sandbox).
+    
+    Args:
+      email: Account email
+      password: Account password
+    """
+    data = {"username": email, "password": password}
+    # form-encoded
+    async with httpx.AsyncClient(timeout=15.0) as c:
+        resp = await c.post(f"{ZOOM_API_URL}/api/v1/auth/login", data=data)
+    if resp.status_code != 200:
+        return json.dumps({"error": f"HTTP {resp.status_code}: {resp.text}"})
+    return json.dumps(resp.json())
+
+
+# Meetings
+def _compose_settings(
+    settings: Optional[Dict[str, Any]],
+    *,
+    waiting_room: Optional[bool] = None,
+    passcode: Optional[str] = None,
+    mute_on_entry: Optional[bool] = None,
+    record_on_start: Optional[bool] = None,
+) -> Optional[Dict[str, Any]]:
+    merged: Dict[str, Any] = {}
+    if isinstance(settings, dict):
+        merged.update({k: v for k, v in settings.items() if v is not None})
+    if waiting_room is not None:
+        merged["waiting_room"] = waiting_room
+    if passcode is not None:
+        merged["passcode"] = passcode
+    if mute_on_entry is not None:
+        merged["mute_on_entry"] = mute_on_entry
+    if record_on_start is not None:
+        merged["record_on_start"] = record_on_start
+    return merged or None
+
+
+@mcp.tool()
+async def meetings_create(
+    topic: str,
+    description: Optional[str] = None,
+    start_time: Optional[str] = None,
+    duration: Optional[int] = None,
+    timezone: str = "UTC",
+    *,
+    waiting_room: Optional[bool] = None,
+    passcode: Optional[str] = None,
+    mute_on_entry: Optional[bool] = None,
+    record_on_start: Optional[bool] = None,
+    settings: Optional[Dict[str, Any]] = None,
+    ) -> str:
+    """Create a meeting.
+    
+    Args:
+      topic: Meeting title (REQUIRED)
+      description: Optional details
+      start_time: RFC3339 or ISO timestamp (e.g., "2025-11-21T10:00:00Z")
+      duration: Minutes
+      timezone: Timezone (default UTC)
+      waiting_room: Enable/disable the waiting room for participants.
+      passcode: Optional meeting passcode string.
+      mute_on_entry: Whether to mute participants on entry.
+      record_on_start: Whether to auto-record when the host joins.
+      settings: Raw settings dict merged with the explicit flags above.
+    """
+    client = await _get_client()
+    meeting_settings = _compose_settings(
+        settings,
+        waiting_room=waiting_room,
+        passcode=passcode,
+        mute_on_entry=mute_on_entry,
+        record_on_start=record_on_start,
+    )
+    payload: Dict[str, Any] = {
+        "topic": topic,
+        "description": description,
+        "start_time": start_time,
+        "duration": duration,
+        "timezone": timezone,
+    }
+    if meeting_settings:
+        payload["settings"] = meeting_settings
+    resp = await client.post(f"{ZOOM_API_URL}/api/v1/meetings", json=payload)
+    return _resp_json(resp)
+
+
+@mcp.tool()
+async def meetings_list() -> str:
+    """List meetings for current user."""
+    client = await _get_client()
+    resp = await client.get(f"{ZOOM_API_URL}/api/v1/meetings")
+    return _resp_json(resp)
+
+
+@mcp.tool()
+async def meetings_get(meeting_id: str) -> str:
+    """Get meeting details.
+    
+    Args:
+      meeting_id: Meeting identifier (REQUIRED)
+    """
+    client = await _get_client()
+    resp = await client.get(f"{ZOOM_API_URL}/api/v1/meetings/{meeting_id}")
+    return _resp_json(resp)
+
+
+@mcp.tool()
+async def meetings_update(
+    meeting_id: str,
+    topic: Optional[str] = None,
+    description: Optional[str] = None,
+    start_time: Optional[str] = None,
+    duration: Optional[int] = None,
+    timezone: Optional[str] = None,
+    *,
+    waiting_room: Optional[bool] = None,
+    passcode: Optional[str] = None,
+    mute_on_entry: Optional[bool] = None,
+    record_on_start: Optional[bool] = None,
+    settings: Optional[Dict[str, Any]] = None,
+    ) -> str:
+    """Update meeting fields (partial).
+    
+    Args:
+      meeting_id: Meeting id (REQUIRED)
+      topic, description, start_time, duration, timezone: Optional updates
+      waiting_room, passcode, mute_on_entry, record_on_start: Optional setting overrides
+      settings: Raw settings dict merged with the explicit flags above
+    """
+    client = await _get_client()
+    body: Dict[str, Any] = {}
+    if topic is not None: body["topic"] = topic
+    if description is not None: body["description"] = description
+    if start_time is not None: body["start_time"] = start_time
+    if duration is not None: body["duration"] = duration
+    if timezone is not None: body["timezone"] = timezone
+    meeting_settings = _compose_settings(
+        settings,
+        waiting_room=waiting_room,
+        passcode=passcode,
+        mute_on_entry=mute_on_entry,
+        record_on_start=record_on_start,
+    )
+    if meeting_settings:
+        body["settings"] = meeting_settings
+    resp = await client.put(f"{ZOOM_API_URL}/api/v1/meetings/{meeting_id}", json=body)
+    return _resp_json(resp)
+
+
+@mcp.tool()
+async def meetings_delete(meeting_id: str) -> str:
+    """Delete a meeting.
+    
+    Args:
+      meeting_id: Meeting id (REQUIRED)
+    """
+    client = await _get_client()
+    resp = await client.delete(f"{ZOOM_API_URL}/api/v1/meetings/{meeting_id}")
+    return _resp_json(resp)
+
+
+@mcp.tool()
+async def meetings_start(meeting_id: str) -> str:
+    """Start a meeting (host action).
+    
+    Args:
+      meeting_id: Meeting id (REQUIRED)
+    """
+    client = await _get_client()
+    resp = await client.post(f"{ZOOM_API_URL}/api/v1/meetings.start", json={"meeting_id": meeting_id})
+    return _resp_json(resp)
+
+
+@mcp.tool()
+async def meetings_join(meeting_id: str) -> str:
+    """Get a join payload/link for the meeting.
+    
+    Args:
+      meeting_id: Meeting id (REQUIRED)
+    """
+    client = await _get_client()
+    resp = await client.post(f"{ZOOM_API_URL}/api/v1/meetings.join", json={"meeting_id": meeting_id})
+    return _resp_json(resp)
+
+
+@mcp.tool()
+async def meetings_end(meeting_id: str) -> str:
+    """End a meeting (host action)."""
+    client = await _get_client()
+    resp = await client.post(f"{ZOOM_API_URL}/api/v1/meetings.end", json={"meeting_id": meeting_id})
+    return _resp_json(resp)
+
+
+@mcp.tool()
+async def meetings_leave(meeting_id: str) -> str:
+    """Leave a meeting (participant action)."""
+    client = await _get_client()
+    resp = await client.post(f"{ZOOM_API_URL}/api/v1/meetings.leave", json={"meeting_id": meeting_id})
+    return _resp_json(resp)
+
+
+# Invitations / Participants
+@mcp.tool()
+async def invitations_create(meeting_id: str, invitee_email: str) -> str:
+    """Create a meeting invitation for an email address."""
+    client = await _get_client()
+    resp = await client.post(f"{ZOOM_API_URL}/api/v1/invitations.create", json={"meeting_id": meeting_id, "invitee_email": invitee_email})
+    return _resp_json(resp)
+
+
+@mcp.tool()
+async def invitations_list(meeting_id: str) -> str:
+    """List invitations for a meeting."""
+    client = await _get_client()
+    resp = await client.get(f"{ZOOM_API_URL}/api/v1/invitations.list", params={"meeting_id": meeting_id})
+    return _resp_json(resp)
+
+
+@mcp.tool()
+async def invitations_accept(invitation_id: str) -> str:
+    """Accept an invitation by id."""
+    client = await _get_client()
+    resp = await client.post(f"{ZOOM_API_URL}/api/v1/invitations.accept", json={"invitation_id": invitation_id})
+    return _resp_json(resp)
+
+
+@mcp.tool()
+async def invitations_decline(invitation_id: str) -> str:
+    """Decline an invitation by id."""
+    client = await _get_client()
+    resp = await client.post(f"{ZOOM_API_URL}/api/v1/invitations.decline", json={"invitation_id": invitation_id})
+    return _resp_json(resp)
+
+
+@mcp.tool()
+async def participants_list(meeting_id: str) -> str:
+    """List participants of a meeting."""
+    client = await _get_client()
+    resp = await client.get(f"{ZOOM_API_URL}/api/v1/participants.list", params={"meeting_id": meeting_id})
+    return _resp_json(resp)
+
+
+@mcp.tool()
+async def participants_admit(meeting_id: str, user_email: str) -> str:
+    """Admit a user into a meeting (host action)."""
+    client = await _get_client()
+    resp = await client.post(f"{ZOOM_API_URL}/api/v1/participants.admit", json={"meeting_id": meeting_id, "user_email": user_email})
+    return _resp_json(resp)
+
+
+@mcp.tool()
+async def participants_remove(meeting_id: str, user_email: str) -> str:
+    """Remove a user from a meeting (host action)."""
+    client = await _get_client()
+    resp = await client.post(f"{ZOOM_API_URL}/api/v1/participants.remove", json={"meeting_id": meeting_id, "user_email": user_email})
+    return _resp_json(resp)
+
+
+@mcp.tool()
+async def participants_set_role(meeting_id: str, user_email: str, role: str) -> str:
+    """Set role for a participant (e.g., host, co-host)."""
+    client = await _get_client()
+    resp = await client.post(f"{ZOOM_API_URL}/api/v1/participants.set_role", json={"meeting_id": meeting_id, "user_email": user_email, "role": role})
+    return _resp_json(resp)
+
+
+# Controls / Chat / Notes / Transcript
+@mcp.tool()
+async def meetings_recording_start(meeting_id: str) -> str:
+    """Start recording a meeting (host action)."""
+    client = await _get_client()
+    resp = await client.post(f"{ZOOM_API_URL}/api/v1/meetings.recording.start", json={"meeting_id": meeting_id})
+    return _resp_json(resp)
+
+
+@mcp.tool()
+async def meetings_recording_stop(meeting_id: str) -> str:
+    """Stop recording a meeting (host action)."""
+    client = await _get_client()
+    resp = await client.post(f"{ZOOM_API_URL}/api/v1/meetings.recording.stop", json={"meeting_id": meeting_id})
+    return _resp_json(resp)
+
+
+@mcp.tool()
+async def chat_post_message(meeting_id: str, content: str) -> str:
+    """Post a chat message in a meeting."""
+    client = await _get_client()
+    resp = await client.post(f"{ZOOM_API_URL}/api/v1/chat.post_message", json={"meeting_id": meeting_id, "content": content})
+    return _resp_json(resp)
+
+
+@mcp.tool()
+async def chat_list(meeting_id: str) -> str:
+    """List chat messages in a meeting."""
+    client = await _get_client()
+    resp = await client.get(f"{ZOOM_API_URL}/api/v1/chat.list", params={"meeting_id": meeting_id})
+    return _resp_json(resp)
+
+
+@mcp.tool()
+async def transcripts_get(meeting_id: str) -> str:
+    """Get meeting transcripts (if available)."""
+    client = await _get_client()
+    resp = await client.get(f"{ZOOM_API_URL}/api/v1/transcripts.get", params={"meeting_id": meeting_id})
+    return _resp_json(resp)
+
+
+@mcp.tool()
+async def transcripts_create(meeting_id: str, start: float, end: float, content: str, speaker: Optional[str] = None) -> str:
+    """Create a transcript segment (sandbox helper)."""
+    client = await _get_client()
+    body = {"meeting_id": meeting_id, "start": start, "end": end, "content": content}
+    if speaker is not None:
+        body["speaker"] = speaker
+    resp = await client.post(f"{ZOOM_API_URL}/api/v1/transcripts.create", json=body)
+    return _resp_json(resp)
+
+
+@mcp.tool()
+async def transcripts_list(meeting_id: str) -> str:
+    """List transcript segments of a meeting."""
+    client = await _get_client()
+    resp = await client.get(f"{ZOOM_API_URL}/api/v1/transcripts.list", params={"meeting_id": meeting_id})
+    return _resp_json(resp)
+
+
+# Profile
+@mcp.tool()
+async def zoom_get_me() -> str:
+    """Get current user profile."""
+    client = await _get_client()
+    resp = await client.get(f"{ZOOM_API_URL}/api/v1/me")
+    return _resp_json(resp)
+
+
+@mcp.tool()
+async def notes_create(meeting_id: str, content: str) -> str:
+    """Create a note for a meeting."""
+    client = await _get_client()
+    resp = await client.post(f"{ZOOM_API_URL}/api/v1/notes.create", json={"meeting_id": meeting_id, "content": content})
+    return _resp_json(resp)
+
+
+@mcp.tool()
+async def notes_list(meeting_id: str) -> str:
+    """List notes of a meeting."""
+    client = await _get_client()
+    resp = await client.get(f"{ZOOM_API_URL}/api/v1/notes.list", params={"meeting_id": meeting_id})
+    return _resp_json(resp)
+
+
+@mcp.tool()
+async def notes_get(note_id: str) -> str:
+    """Get a note by id."""
+    client = await _get_client()
+    resp = await client.get(f"{ZOOM_API_URL}/api/v1/notes.get", params={"note_id": note_id})
+    return _resp_json(resp)
+
+
+@mcp.tool()
+async def notes_update(note_id: str, content: str) -> str:
+    """Update a note's content."""
+    client = await _get_client()
+    resp = await client.post(f"{ZOOM_API_URL}/api/v1/notes.update", json={"note_id": note_id, "content": content})
+    return _resp_json(resp)
+
+
+@mcp.tool()
+async def notes_delete(note_id: str) -> str:
+    """Delete a note by id."""
+    client = await _get_client()
+    resp = await client.post(f"{ZOOM_API_URL}/api/v1/notes.delete", json={"note_id": note_id})
+    return _resp_json(resp)
+
+
+def _resp_json(resp: httpx.Response) -> str:
+    if resp.status_code < 200 or resp.status_code >= 300:
+        try:
+            return json.dumps({"error": f"HTTP {resp.status_code}: {resp.text}"})
+        except Exception:
+            return json.dumps({"error": f"HTTP {resp.status_code}"})
+    try:
+        return json.dumps(resp.json())
+    except Exception:
+        return json.dumps({"ok": True})
+
+
+def main() -> None:
+    print("Starting Zoom MCP Server (Sandbox)...", file=sys.stderr)
+    sys.stderr.flush()
+    host = os.getenv("ZOOM_MCP_HOST", "localhost")
+    env_port = os.getenv("PORT", "").strip()
+    if env_port.isdigit():
+        port = int(env_port)
+    else:
+        port = _port_from_registry(8851)
+    mcp.run(transport="http", host=host, port=port)
+
+
+if __name__ == "__main__":
+    main()
+
+