feat: Complete Bannerlord MCP Harness implementation (Issue #722)
Some checks failed
Deploy Nexus / deploy (push) Failing after 4s
Some checks failed
Deploy Nexus / deploy (push) Failing after 4s
Implements the Hermes observation/control path for local Bannerlord per GamePortal Protocol. ## New Components - nexus/bannerlord_harness.py (874 lines) - MCPClient for JSON-RPC communication with MCP servers - capture_state() → GameState with visual + Steam context - execute_action() → ActionResult for all input types - observe-decide-act loop with telemetry through Hermes WS - Bannerlord-specific actions (inventory, party, save/load) - Mock mode for testing without game running - mcp_servers/desktop_control_server.py (14KB) - 13 desktop automation tools via pyautogui - Screenshot, mouse, keyboard control - Headless environment support - mcp_servers/steam_info_server.py (18KB) - 6 Steam Web API tools - Mock mode without API key, live mode with STEAM_API_KEY - tests/test_bannerlord_harness.py (37 tests, all passing) - GameState/ActionResult validation - Mock mode action tests - ODA loop tests - GamePortal Protocol compliance tests - docs/BANNERLORD_HARNESS_PROOF.md - Architecture documentation - Proof of ODA loop execution - Telemetry flow diagrams - examples/harness_demo.py - Runnable demo showing full ODA loop ## Updates - portals.json: Bannerlord metadata per GAMEPORTAL_PROTOCOL.md - status: active, portal_type: game-world - app_id: 261550, window_title: 'Mount & Blade II: Bannerlord' - telemetry_source: hermes-harness:bannerlord ## Verification pytest tests/test_bannerlord_harness.py -v 37 passed, 2 skipped, 11 warnings Closes #722
This commit is contained in:
Allegro (Burn Mode)
94
mcp_servers/README.md
Normal file
94
mcp_servers/README.md
Normal file
@@ -0,0 +1,94 @@
|
||||
# MCP Servers for Bannerlord Harness
|
||||
|
||||
This directory contains MCP (Model Context Protocol) servers that provide tools for desktop control and Steam integration.
|
||||
|
||||
## Overview
|
||||
|
||||
MCP servers use stdio JSON-RPC for communication:
|
||||
- Read requests from stdin (line-delimited JSON)
|
||||
- Write responses to stdout (line-delimited JSON)
|
||||
- Each request has: `jsonrpc`, `id`, `method`, `params`
|
||||
- Each response has: `jsonrpc`, `id`, `result` or `error`
|
||||
|
||||
## Servers
|
||||
|
||||
### Desktop Control Server (`desktop_control_server.py`)
|
||||
|
||||
Provides desktop automation capabilities using pyautogui.
|
||||
|
||||
**Tools:**
|
||||
- `take_screenshot(path)` - Capture screen and save to path
|
||||
- `get_screen_size()` - Return screen dimensions
|
||||
- `get_mouse_position()` - Return current mouse coordinates
|
||||
- `pixel_color(x, y)` - Get RGB color at coordinate
|
||||
- `click(x, y)` - Left click at position
|
||||
- `right_click(x, y)` - Right click at position
|
||||
- `move_to(x, y)` - Move mouse to position
|
||||
- `drag_to(x, y, duration)` - Drag with duration
|
||||
- `type_text(text)` - Type string
|
||||
- `press_key(key)` - Press single key
|
||||
- `hotkey(keys)` - Press key combo (space-separated)
|
||||
- `scroll(amount)` - Scroll wheel
|
||||
- `get_os()` - Return OS info
|
||||
|
||||
**Note:** In headless environments, pyautogui features requiring a display will return errors.
|
||||
|
||||
### Steam Info Server (`steam_info_server.py`)
|
||||
|
||||
Provides Steam Web API integration for game data.
|
||||
|
||||
**Tools:**
|
||||
- `steam_recently_played(user_id, count)` - Recent games for user
|
||||
- `steam_player_achievements(user_id, app_id)` - Achievement data
|
||||
- `steam_user_stats(user_id, app_id)` - Game stats
|
||||
- `steam_current_players(app_id)` - Online count
|
||||
- `steam_news(app_id, count)` - Game news
|
||||
- `steam_app_details(app_id)` - App details
|
||||
|
||||
**Configuration:**
|
||||
Set `STEAM_API_KEY` environment variable to use live Steam API. Without a key, the server runs in mock mode with sample data.
|
||||
|
||||
## Configuration
|
||||
|
||||
The `mcp_config.json` in the repository root configures the servers for MCP clients:
|
||||
|
||||
```json
|
||||
{
|
||||
"mcpServers": {
|
||||
"desktop-control": {
|
||||
"command": "python3",
|
||||
"args": ["mcp_servers/desktop_control_server.py"]
|
||||
},
|
||||
"steam-info": {
|
||||
"command": "python3",
|
||||
"args": ["mcp_servers/steam_info_server.py"]
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Testing
|
||||
|
||||
Run the test script to verify both servers:
|
||||
|
||||
```bash
|
||||
python3 mcp_servers/test_servers.py
|
||||
```
|
||||
|
||||
Or test manually:
|
||||
|
||||
```bash
|
||||
# Test desktop control server
|
||||
echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}' | python3 mcp_servers/desktop_control_server.py
|
||||
|
||||
# Test Steam info server
|
||||
echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}' | python3 mcp_servers/steam_info_server.py
|
||||
```
|
||||
|
||||
## Bannerlord Integration
|
||||
|
||||
These servers can be used to:
|
||||
- Capture screenshots of the game
|
||||
- Read game UI elements via pixel color
|
||||
- Track Bannerlord playtime and achievements via Steam
|
||||
- Automate game interactions for testing
|
||||
412
mcp_servers/desktop_control_server.py
Executable file
412
mcp_servers/desktop_control_server.py
Executable file
@@ -0,0 +1,412 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
MCP Server for Desktop Control
|
||||
Provides screen capture, mouse, and keyboard control via pyautogui.
|
||||
Uses stdio JSON-RPC for MCP protocol.
|
||||
"""
|
||||
|
||||
import json
|
||||
import sys
|
||||
import logging
|
||||
import os
|
||||
from typing import Any, Dict, List, Optional
|
||||
|
||||
# Set up logging to stderr (stdout is for JSON-RPC)
|
||||
logging.basicConfig(
|
||||
level=logging.INFO,
|
||||
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
|
||||
stream=sys.stderr
|
||||
)
|
||||
logger = logging.getLogger('desktop-control-mcp')
|
||||
|
||||
# Import pyautogui for desktop control
|
||||
try:
|
||||
import pyautogui
|
||||
# Configure pyautogui for safety
|
||||
pyautogui.FAILSAFE = True
|
||||
pyautogui.PAUSE = 0.1
|
||||
PYAUTOGUI_AVAILABLE = True
|
||||
except ImportError:
|
||||
logger.error("pyautogui not available - desktop control will be limited")
|
||||
PYAUTOGUI_AVAILABLE = False
|
||||
except Exception as e:
|
||||
# Handle headless environments and other display-related errors
|
||||
logger.warning(f"pyautogui import failed (likely headless environment): {e}")
|
||||
PYAUTOGUI_AVAILABLE = False
|
||||
|
||||
|
||||
class DesktopControlMCPServer:
|
||||
"""MCP Server providing desktop control capabilities."""
|
||||
|
||||
def __init__(self):
|
||||
self.tools = self._define_tools()
|
||||
|
||||
def _define_tools(self) -> List[Dict[str, Any]]:
|
||||
"""Define the available tools for this MCP server."""
|
||||
return [
|
||||
{
|
||||
"name": "take_screenshot",
|
||||
"description": "Capture a screenshot and save it to the specified path",
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"path": {
|
||||
"type": "string",
|
||||
"description": "File path to save the screenshot"
|
||||
}
|
||||
},
|
||||
"required": ["path"]
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "get_screen_size",
|
||||
"description": "Get the current screen dimensions",
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {}
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "get_mouse_position",
|
||||
"description": "Get the current mouse cursor position",
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {}
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "pixel_color",
|
||||
"description": "Get the RGB color of a pixel at the specified coordinates",
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"x": {"type": "integer", "description": "X coordinate"},
|
||||
"y": {"type": "integer", "description": "Y coordinate"}
|
||||
},
|
||||
"required": ["x", "y"]
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "click",
|
||||
"description": "Perform a left mouse click at the specified coordinates",
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"x": {"type": "integer", "description": "X coordinate"},
|
||||
"y": {"type": "integer", "description": "Y coordinate"}
|
||||
},
|
||||
"required": ["x", "y"]
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "right_click",
|
||||
"description": "Perform a right mouse click at the specified coordinates",
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"x": {"type": "integer", "description": "X coordinate"},
|
||||
"y": {"type": "integer", "description": "Y coordinate"}
|
||||
},
|
||||
"required": ["x", "y"]
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "move_to",
|
||||
"description": "Move the mouse cursor to the specified coordinates",
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"x": {"type": "integer", "description": "X coordinate"},
|
||||
"y": {"type": "integer", "description": "Y coordinate"}
|
||||
},
|
||||
"required": ["x", "y"]
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "drag_to",
|
||||
"description": "Drag the mouse to the specified coordinates with optional duration",
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"x": {"type": "integer", "description": "X coordinate"},
|
||||
"y": {"type": "integer", "description": "Y coordinate"},
|
||||
"duration": {"type": "number", "description": "Duration of drag in seconds", "default": 0.5}
|
||||
},
|
||||
"required": ["x", "y"]
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "type_text",
|
||||
"description": "Type the specified text string",
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"text": {"type": "string", "description": "Text to type"}
|
||||
},
|
||||
"required": ["text"]
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "press_key",
|
||||
"description": "Press a single key",
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"key": {"type": "string", "description": "Key to press (e.g., 'enter', 'space', 'a', 'f1')"}
|
||||
},
|
||||
"required": ["key"]
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "hotkey",
|
||||
"description": "Press a key combination (space-separated keys)",
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"keys": {"type": "string", "description": "Space-separated keys (e.g., 'ctrl alt t')"}
|
||||
},
|
||||
"required": ["keys"]
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "scroll",
|
||||
"description": "Scroll the mouse wheel",
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"amount": {"type": "integer", "description": "Amount to scroll (positive for up, negative for down)"}
|
||||
},
|
||||
"required": ["amount"]
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "get_os",
|
||||
"description": "Get information about the operating system",
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {}
|
||||
}
|
||||
}
|
||||
]
|
||||
|
||||
def handle_initialize(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
||||
"""Handle the initialize request."""
|
||||
logger.info("Received initialize request")
|
||||
return {
|
||||
"protocolVersion": "2024-11-05",
|
||||
"serverInfo": {
|
||||
"name": "desktop-control-mcp",
|
||||
"version": "1.0.0"
|
||||
},
|
||||
"capabilities": {
|
||||
"tools": {}
|
||||
}
|
||||
}
|
||||
|
||||
def handle_tools_list(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
||||
"""Handle the tools/list request."""
|
||||
return {"tools": self.tools}
|
||||
|
||||
def handle_tools_call(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
||||
"""Handle the tools/call request."""
|
||||
tool_name = params.get("name", "")
|
||||
arguments = params.get("arguments", {})
|
||||
|
||||
logger.info(f"Tool call: {tool_name} with args: {arguments}")
|
||||
|
||||
if not PYAUTOGUI_AVAILABLE and tool_name != "get_os":
|
||||
return {
|
||||
"content": [
|
||||
{
|
||||
"type": "text",
|
||||
"text": json.dumps({"error": "pyautogui not available"})
|
||||
}
|
||||
],
|
||||
"isError": True
|
||||
}
|
||||
|
||||
try:
|
||||
result = self._execute_tool(tool_name, arguments)
|
||||
return {
|
||||
"content": [
|
||||
{
|
||||
"type": "text",
|
||||
"text": json.dumps(result)
|
||||
}
|
||||
],
|
||||
"isError": False
|
||||
}
|
||||
except Exception as e:
|
||||
logger.error(f"Error executing tool {tool_name}: {e}")
|
||||
return {
|
||||
"content": [
|
||||
{
|
||||
"type": "text",
|
||||
"text": json.dumps({"error": str(e)})
|
||||
}
|
||||
],
|
||||
"isError": True
|
||||
}
|
||||
|
||||
def _execute_tool(self, name: str, args: Dict[str, Any]) -> Dict[str, Any]:
|
||||
"""Execute the specified tool with the given arguments."""
|
||||
if name == "take_screenshot":
|
||||
path = args.get("path", "screenshot.png")
|
||||
screenshot = pyautogui.screenshot()
|
||||
screenshot.save(path)
|
||||
return {"success": True, "path": path}
|
||||
|
||||
elif name == "get_screen_size":
|
||||
width, height = pyautogui.size()
|
||||
return {"width": width, "height": height}
|
||||
|
||||
elif name == "get_mouse_position":
|
||||
x, y = pyautogui.position()
|
||||
return {"x": x, "y": y}
|
||||
|
||||
elif name == "pixel_color":
|
||||
x = args.get("x", 0)
|
||||
y = args.get("y", 0)
|
||||
color = pyautogui.pixel(x, y)
|
||||
return {"r": color[0], "g": color[1], "b": color[2], "rgb": list(color)}
|
||||
|
||||
elif name == "click":
|
||||
x = args.get("x")
|
||||
y = args.get("y")
|
||||
pyautogui.click(x, y)
|
||||
return {"success": True, "x": x, "y": y}
|
||||
|
||||
elif name == "right_click":
|
||||
x = args.get("x")
|
||||
y = args.get("y")
|
||||
pyautogui.rightClick(x, y)
|
||||
return {"success": True, "x": x, "y": y}
|
||||
|
||||
elif name == "move_to":
|
||||
x = args.get("x")
|
||||
y = args.get("y")
|
||||
pyautogui.moveTo(x, y)
|
||||
return {"success": True, "x": x, "y": y}
|
||||
|
||||
elif name == "drag_to":
|
||||
x = args.get("x")
|
||||
y = args.get("y")
|
||||
duration = args.get("duration", 0.5)
|
||||
pyautogui.dragTo(x, y, duration=duration)
|
||||
return {"success": True, "x": x, "y": y, "duration": duration}
|
||||
|
||||
elif name == "type_text":
|
||||
text = args.get("text", "")
|
||||
pyautogui.typewrite(text)
|
||||
return {"success": True, "text": text}
|
||||
|
||||
elif name == "press_key":
|
||||
key = args.get("key", "")
|
||||
pyautogui.press(key)
|
||||
return {"success": True, "key": key}
|
||||
|
||||
elif name == "hotkey":
|
||||
keys_str = args.get("keys", "")
|
||||
keys = keys_str.split()
|
||||
pyautogui.hotkey(*keys)
|
||||
return {"success": True, "keys": keys}
|
||||
|
||||
elif name == "scroll":
|
||||
amount = args.get("amount", 0)
|
||||
pyautogui.scroll(amount)
|
||||
return {"success": True, "amount": amount}
|
||||
|
||||
elif name == "get_os":
|
||||
import platform
|
||||
return {
|
||||
"system": platform.system(),
|
||||
"release": platform.release(),
|
||||
"version": platform.version(),
|
||||
"machine": platform.machine(),
|
||||
"processor": platform.processor(),
|
||||
"platform": platform.platform()
|
||||
}
|
||||
|
||||
else:
|
||||
raise ValueError(f"Unknown tool: {name}")
|
||||
|
||||
def process_request(self, request: Dict[str, Any]) -> Optional[Dict[str, Any]]:
|
||||
"""Process an MCP request and return the response."""
|
||||
method = request.get("method", "")
|
||||
params = request.get("params", {})
|
||||
req_id = request.get("id")
|
||||
|
||||
if method == "initialize":
|
||||
result = self.handle_initialize(params)
|
||||
elif method == "tools/list":
|
||||
result = self.handle_tools_list(params)
|
||||
elif method == "tools/call":
|
||||
result = self.handle_tools_call(params)
|
||||
else:
|
||||
# Unknown method
|
||||
return {
|
||||
"jsonrpc": "2.0",
|
||||
"id": req_id,
|
||||
"error": {
|
||||
"code": -32601,
|
||||
"message": f"Method not found: {method}"
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
"jsonrpc": "2.0",
|
||||
"id": req_id,
|
||||
"result": result
|
||||
}
|
||||
|
||||
|
||||
def main():
|
||||
"""Main entry point for the MCP server."""
|
||||
logger.info("Desktop Control MCP Server starting...")
|
||||
|
||||
server = DesktopControlMCPServer()
|
||||
|
||||
# Check if running in a TTY (for testing)
|
||||
if sys.stdin.isatty():
|
||||
logger.info("Running in interactive mode (for testing)")
|
||||
print("Desktop Control MCP Server", file=sys.stderr)
|
||||
print("Enter JSON-RPC requests (one per line):", file=sys.stderr)
|
||||
|
||||
try:
|
||||
while True:
|
||||
# Read line from stdin
|
||||
line = sys.stdin.readline()
|
||||
if not line:
|
||||
break
|
||||
|
||||
line = line.strip()
|
||||
if not line:
|
||||
continue
|
||||
|
||||
try:
|
||||
request = json.loads(line)
|
||||
response = server.process_request(request)
|
||||
if response:
|
||||
print(json.dumps(response), flush=True)
|
||||
except json.JSONDecodeError as e:
|
||||
logger.error(f"Invalid JSON: {e}")
|
||||
error_response = {
|
||||
"jsonrpc": "2.0",
|
||||
"id": None,
|
||||
"error": {
|
||||
"code": -32700,
|
||||
"message": "Parse error"
|
||||
}
|
||||
}
|
||||
print(json.dumps(error_response), flush=True)
|
||||
|
||||
except KeyboardInterrupt:
|
||||
logger.info("Received keyboard interrupt, shutting down...")
|
||||
except Exception as e:
|
||||
logger.error(f"Unexpected error: {e}")
|
||||
|
||||
logger.info("Desktop Control MCP Server stopped.")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
480
mcp_servers/steam_info_server.py
Executable file
480
mcp_servers/steam_info_server.py
Executable file
@@ -0,0 +1,480 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
MCP Server for Steam Information
|
||||
Provides Steam Web API integration for game data.
|
||||
Uses stdio JSON-RPC for MCP protocol.
|
||||
"""
|
||||
|
||||
import json
|
||||
import sys
|
||||
import logging
|
||||
import os
|
||||
import urllib.request
|
||||
import urllib.error
|
||||
from typing import Any, Dict, List, Optional
|
||||
|
||||
# Set up logging to stderr (stdout is for JSON-RPC)
|
||||
logging.basicConfig(
|
||||
level=logging.INFO,
|
||||
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
|
||||
stream=sys.stderr
|
||||
)
|
||||
logger = logging.getLogger('steam-info-mcp')
|
||||
|
||||
# Steam API configuration
|
||||
STEAM_API_BASE = "https://api.steampowered.com"
|
||||
STEAM_API_KEY = os.environ.get('STEAM_API_KEY', '')
|
||||
|
||||
# Bannerlord App ID for convenience
|
||||
BANNERLORD_APP_ID = "261550"
|
||||
|
||||
|
||||
class SteamInfoMCPServer:
|
||||
"""MCP Server providing Steam information capabilities."""
|
||||
|
||||
def __init__(self):
|
||||
self.tools = self._define_tools()
|
||||
self.mock_mode = not STEAM_API_KEY
|
||||
if self.mock_mode:
|
||||
logger.warning("No STEAM_API_KEY found - running in mock mode")
|
||||
|
||||
def _define_tools(self) -> List[Dict[str, Any]]:
|
||||
"""Define the available tools for this MCP server."""
|
||||
return [
|
||||
{
|
||||
"name": "steam_recently_played",
|
||||
"description": "Get recently played games for a Steam user",
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"user_id": {
|
||||
"type": "string",
|
||||
"description": "Steam User ID (64-bit SteamID)"
|
||||
},
|
||||
"count": {
|
||||
"type": "integer",
|
||||
"description": "Number of games to return",
|
||||
"default": 10
|
||||
}
|
||||
},
|
||||
"required": ["user_id"]
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "steam_player_achievements",
|
||||
"description": "Get achievement data for a player and game",
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"user_id": {
|
||||
"type": "string",
|
||||
"description": "Steam User ID (64-bit SteamID)"
|
||||
},
|
||||
"app_id": {
|
||||
"type": "string",
|
||||
"description": "Steam App ID of the game"
|
||||
}
|
||||
},
|
||||
"required": ["user_id", "app_id"]
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "steam_user_stats",
|
||||
"description": "Get user statistics for a specific game",
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"user_id": {
|
||||
"type": "string",
|
||||
"description": "Steam User ID (64-bit SteamID)"
|
||||
},
|
||||
"app_id": {
|
||||
"type": "string",
|
||||
"description": "Steam App ID of the game"
|
||||
}
|
||||
},
|
||||
"required": ["user_id", "app_id"]
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "steam_current_players",
|
||||
"description": "Get current number of players for a game",
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"app_id": {
|
||||
"type": "string",
|
||||
"description": "Steam App ID of the game"
|
||||
}
|
||||
},
|
||||
"required": ["app_id"]
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "steam_news",
|
||||
"description": "Get news articles for a game",
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"app_id": {
|
||||
"type": "string",
|
||||
"description": "Steam App ID of the game"
|
||||
},
|
||||
"count": {
|
||||
"type": "integer",
|
||||
"description": "Number of news items to return",
|
||||
"default": 5
|
||||
}
|
||||
},
|
||||
"required": ["app_id"]
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "steam_app_details",
|
||||
"description": "Get detailed information about a Steam app",
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"app_id": {
|
||||
"type": "string",
|
||||
"description": "Steam App ID"
|
||||
}
|
||||
},
|
||||
"required": ["app_id"]
|
||||
}
|
||||
}
|
||||
]
|
||||
|
||||
def _make_steam_api_request(self, endpoint: str, params: Dict[str, str]) -> Dict[str, Any]:
|
||||
"""Make a request to the Steam Web API."""
|
||||
if self.mock_mode:
|
||||
raise Exception("Steam API key not configured - running in mock mode")
|
||||
|
||||
# Add API key to params
|
||||
params['key'] = STEAM_API_KEY
|
||||
|
||||
# Build query string
|
||||
query = '&'.join(f"{k}={urllib.parse.quote(str(v))}" for k, v in params.items())
|
||||
url = f"{STEAM_API_BASE}/{endpoint}?{query}"
|
||||
|
||||
try:
|
||||
with urllib.request.urlopen(url, timeout=10) as response:
|
||||
data = json.loads(response.read().decode('utf-8'))
|
||||
return data
|
||||
except urllib.error.HTTPError as e:
|
||||
logger.error(f"HTTP Error {e.code}: {e.reason}")
|
||||
raise Exception(f"Steam API HTTP error: {e.code}")
|
||||
except urllib.error.URLError as e:
|
||||
logger.error(f"URL Error: {e.reason}")
|
||||
raise Exception(f"Steam API connection error: {e.reason}")
|
||||
except json.JSONDecodeError as e:
|
||||
logger.error(f"JSON decode error: {e}")
|
||||
raise Exception("Invalid response from Steam API")
|
||||
|
||||
def _get_mock_data(self, method: str, params: Dict[str, Any]) -> Dict[str, Any]:
|
||||
"""Return mock data for testing without API key."""
|
||||
app_id = params.get("app_id", BANNERLORD_APP_ID)
|
||||
user_id = params.get("user_id", "123456789")
|
||||
|
||||
if method == "steam_recently_played":
|
||||
return {
|
||||
"mock": True,
|
||||
"user_id": user_id,
|
||||
"total_count": 3,
|
||||
"games": [
|
||||
{
|
||||
"appid": 261550,
|
||||
"name": "Mount & Blade II: Bannerlord",
|
||||
"playtime_2weeks": 1425,
|
||||
"playtime_forever": 15230,
|
||||
"img_icon_url": "mock_icon_url"
|
||||
},
|
||||
{
|
||||
"appid": 730,
|
||||
"name": "Counter-Strike 2",
|
||||
"playtime_2weeks": 300,
|
||||
"playtime_forever": 5000,
|
||||
"img_icon_url": "mock_icon_url"
|
||||
}
|
||||
]
|
||||
}
|
||||
elif method == "steam_player_achievements":
|
||||
return {
|
||||
"mock": True,
|
||||
"player_id": user_id,
|
||||
"game_name": "Mock Game",
|
||||
"achievements": [
|
||||
{"apiname": "achievement_1", "achieved": 1, "unlocktime": 1700000000},
|
||||
{"apiname": "achievement_2", "achieved": 0},
|
||||
{"apiname": "achievement_3", "achieved": 1, "unlocktime": 1700100000}
|
||||
],
|
||||
"success": True
|
||||
}
|
||||
elif method == "steam_user_stats":
|
||||
return {
|
||||
"mock": True,
|
||||
"player_id": user_id,
|
||||
"game_id": app_id,
|
||||
"stats": [
|
||||
{"name": "kills", "value": 1250},
|
||||
{"name": "deaths", "value": 450},
|
||||
{"name": "wins", "value": 89}
|
||||
],
|
||||
"achievements": [
|
||||
{"name": "first_victory", "achieved": 1}
|
||||
]
|
||||
}
|
||||
elif method == "steam_current_players":
|
||||
return {
|
||||
"mock": True,
|
||||
"app_id": app_id,
|
||||
"player_count": 15432,
|
||||
"result": 1
|
||||
}
|
||||
elif method == "steam_news":
|
||||
return {
|
||||
"mock": True,
|
||||
"appid": app_id,
|
||||
"newsitems": [
|
||||
{
|
||||
"gid": "12345",
|
||||
"title": "Major Update Released!",
|
||||
"url": "https://steamcommunity.com/games/261550/announcements/detail/mock",
|
||||
"author": "Developer",
|
||||
"contents": "This is a mock news item for testing purposes.",
|
||||
"feedlabel": "Product Update",
|
||||
"date": 1700000000
|
||||
},
|
||||
{
|
||||
"gid": "12346",
|
||||
"title": "Patch Notes 1.2.3",
|
||||
"url": "https://steamcommunity.com/games/261550/announcements/detail/mock2",
|
||||
"author": "Developer",
|
||||
"contents": "Bug fixes and improvements.",
|
||||
"feedlabel": "Patch Notes",
|
||||
"date": 1699900000
|
||||
}
|
||||
],
|
||||
"count": 2
|
||||
}
|
||||
elif method == "steam_app_details":
|
||||
return {
|
||||
"mock": True,
|
||||
app_id: {
|
||||
"success": True,
|
||||
"data": {
|
||||
"type": "game",
|
||||
"name": "Mock Game Title",
|
||||
"steam_appid": int(app_id),
|
||||
"required_age": 0,
|
||||
"is_free": False,
|
||||
"detailed_description": "This is a mock description.",
|
||||
"about_the_game": "About the mock game.",
|
||||
"short_description": "A short mock description.",
|
||||
"developers": ["Mock Developer"],
|
||||
"publishers": ["Mock Publisher"],
|
||||
"genres": [{"id": "1", "description": "Action"}],
|
||||
"release_date": {"coming_soon": False, "date": "1 Jan, 2024"}
|
||||
}
|
||||
}
|
||||
}
|
||||
return {"mock": True, "message": "Unknown method"}
|
||||
|
||||
def handle_initialize(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
||||
"""Handle the initialize request."""
|
||||
logger.info("Received initialize request")
|
||||
return {
|
||||
"protocolVersion": "2024-11-05",
|
||||
"serverInfo": {
|
||||
"name": "steam-info-mcp",
|
||||
"version": "1.0.0"
|
||||
},
|
||||
"capabilities": {
|
||||
"tools": {}
|
||||
}
|
||||
}
|
||||
|
||||
def handle_tools_list(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
||||
"""Handle the tools/list request."""
|
||||
return {"tools": self.tools}
|
||||
|
||||
def handle_tools_call(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
||||
"""Handle the tools/call request."""
|
||||
tool_name = params.get("name", "")
|
||||
arguments = params.get("arguments", {})
|
||||
|
||||
logger.info(f"Tool call: {tool_name} with args: {arguments}")
|
||||
|
||||
try:
|
||||
result = self._execute_tool(tool_name, arguments)
|
||||
return {
|
||||
"content": [
|
||||
{
|
||||
"type": "text",
|
||||
"text": json.dumps(result)
|
||||
}
|
||||
],
|
||||
"isError": False
|
||||
}
|
||||
except Exception as e:
|
||||
logger.error(f"Error executing tool {tool_name}: {e}")
|
||||
return {
|
||||
"content": [
|
||||
{
|
||||
"type": "text",
|
||||
"text": json.dumps({"error": str(e)})
|
||||
}
|
||||
],
|
||||
"isError": True
|
||||
}
|
||||
|
||||
def _execute_tool(self, name: str, args: Dict[str, Any]) -> Dict[str, Any]:
|
||||
"""Execute the specified tool with the given arguments."""
|
||||
if self.mock_mode:
|
||||
logger.info(f"Returning mock data for {name}")
|
||||
return self._get_mock_data(name, args)
|
||||
|
||||
# Real Steam API calls (when API key is configured)
|
||||
if name == "steam_recently_played":
|
||||
user_id = args.get("user_id")
|
||||
count = args.get("count", 10)
|
||||
data = self._make_steam_api_request(
|
||||
"IPlayerService/GetRecentlyPlayedGames/v1",
|
||||
{"steamid": user_id, "count": str(count)}
|
||||
)
|
||||
return data.get("response", {})
|
||||
|
||||
elif name == "steam_player_achievements":
|
||||
user_id = args.get("user_id")
|
||||
app_id = args.get("app_id")
|
||||
data = self._make_steam_api_request(
|
||||
"ISteamUserStats/GetPlayerAchievements/v1",
|
||||
{"steamid": user_id, "appid": app_id}
|
||||
)
|
||||
return data.get("playerstats", {})
|
||||
|
||||
elif name == "steam_user_stats":
|
||||
user_id = args.get("user_id")
|
||||
app_id = args.get("app_id")
|
||||
data = self._make_steam_api_request(
|
||||
"ISteamUserStats/GetUserStatsForGame/v2",
|
||||
{"steamid": user_id, "appid": app_id}
|
||||
)
|
||||
return data.get("playerstats", {})
|
||||
|
||||
elif name == "steam_current_players":
|
||||
app_id = args.get("app_id")
|
||||
data = self._make_steam_api_request(
|
||||
"ISteamUserStats/GetNumberOfCurrentPlayers/v1",
|
||||
{"appid": app_id}
|
||||
)
|
||||
return data.get("response", {})
|
||||
|
||||
elif name == "steam_news":
|
||||
app_id = args.get("app_id")
|
||||
count = args.get("count", 5)
|
||||
data = self._make_steam_api_request(
|
||||
"ISteamNews/GetNewsForApp/v2",
|
||||
{"appid": app_id, "count": str(count), "maxlength": "300"}
|
||||
)
|
||||
return data.get("appnews", {})
|
||||
|
||||
elif name == "steam_app_details":
|
||||
app_id = args.get("app_id")
|
||||
# App details uses a different endpoint
|
||||
url = f"https://store.steampowered.com/api/appdetails?appids={app_id}"
|
||||
try:
|
||||
with urllib.request.urlopen(url, timeout=10) as response:
|
||||
data = json.loads(response.read().decode('utf-8'))
|
||||
return data
|
||||
except Exception as e:
|
||||
raise Exception(f"Failed to fetch app details: {e}")
|
||||
|
||||
else:
|
||||
raise ValueError(f"Unknown tool: {name}")
|
||||
|
||||
def process_request(self, request: Dict[str, Any]) -> Optional[Dict[str, Any]]:
|
||||
"""Process an MCP request and return the response."""
|
||||
method = request.get("method", "")
|
||||
params = request.get("params", {})
|
||||
req_id = request.get("id")
|
||||
|
||||
if method == "initialize":
|
||||
result = self.handle_initialize(params)
|
||||
elif method == "tools/list":
|
||||
result = self.handle_tools_list(params)
|
||||
elif method == "tools/call":
|
||||
result = self.handle_tools_call(params)
|
||||
else:
|
||||
# Unknown method
|
||||
return {
|
||||
"jsonrpc": "2.0",
|
||||
"id": req_id,
|
||||
"error": {
|
||||
"code": -32601,
|
||||
"message": f"Method not found: {method}"
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
"jsonrpc": "2.0",
|
||||
"id": req_id,
|
||||
"result": result
|
||||
}
|
||||
|
||||
|
||||
def main():
|
||||
"""Main entry point for the MCP server."""
|
||||
logger.info("Steam Info MCP Server starting...")
|
||||
|
||||
if STEAM_API_KEY:
|
||||
logger.info("Steam API key configured - using live API")
|
||||
else:
|
||||
logger.warning("No STEAM_API_KEY found - running in mock mode")
|
||||
|
||||
server = SteamInfoMCPServer()
|
||||
|
||||
# Check if running in a TTY (for testing)
|
||||
if sys.stdin.isatty():
|
||||
logger.info("Running in interactive mode (for testing)")
|
||||
print("Steam Info MCP Server", file=sys.stderr)
|
||||
print("Enter JSON-RPC requests (one per line):", file=sys.stderr)
|
||||
|
||||
try:
|
||||
while True:
|
||||
# Read line from stdin
|
||||
line = sys.stdin.readline()
|
||||
if not line:
|
||||
break
|
||||
|
||||
line = line.strip()
|
||||
if not line:
|
||||
continue
|
||||
|
||||
try:
|
||||
request = json.loads(line)
|
||||
response = server.process_request(request)
|
||||
if response:
|
||||
print(json.dumps(response), flush=True)
|
||||
except json.JSONDecodeError as e:
|
||||
logger.error(f"Invalid JSON: {e}")
|
||||
error_response = {
|
||||
"jsonrpc": "2.0",
|
||||
"id": None,
|
||||
"error": {
|
||||
"code": -32700,
|
||||
"message": "Parse error"
|
||||
}
|
||||
}
|
||||
print(json.dumps(error_response), flush=True)
|
||||
|
||||
except KeyboardInterrupt:
|
||||
logger.info("Received keyboard interrupt, shutting down...")
|
||||
except Exception as e:
|
||||
logger.error(f"Unexpected error: {e}")
|
||||
|
||||
logger.info("Steam Info MCP Server stopped.")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
239
mcp_servers/test_servers.py
Normal file
239
mcp_servers/test_servers.py
Normal file
@@ -0,0 +1,239 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Test script for MCP servers.
|
||||
Validates that both desktop-control and steam-info servers respond correctly to MCP requests.
|
||||
"""
|
||||
|
||||
import json
|
||||
import subprocess
|
||||
import sys
|
||||
from typing import Dict, Any, Tuple, List
|
||||
|
||||
|
||||
def send_request(server_script: str, request: Dict[str, Any]) -> Tuple[bool, Dict[str, Any], str]:
|
||||
"""Send a JSON-RPC request to an MCP server and return the response."""
|
||||
try:
|
||||
proc = subprocess.run(
|
||||
["python3", server_script],
|
||||
input=json.dumps(request) + "\n",
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
|
||||
# Parse stdout for JSON-RPC response
|
||||
for line in proc.stdout.strip().split("\n"):
|
||||
line = line.strip()
|
||||
if line and line.startswith("{"):
|
||||
try:
|
||||
response = json.loads(line)
|
||||
if "jsonrpc" in response:
|
||||
return True, response, ""
|
||||
except json.JSONDecodeError:
|
||||
continue
|
||||
|
||||
return False, {}, f"No valid JSON-RPC response found. stderr: {proc.stderr}"
|
||||
|
||||
except subprocess.TimeoutExpired:
|
||||
return False, {}, "Server timed out"
|
||||
except Exception as e:
|
||||
return False, {}, str(e)
|
||||
|
||||
|
||||
def test_desktop_control_server() -> List[str]:
|
||||
"""Test the desktop control MCP server."""
|
||||
errors = []
|
||||
server = "mcp_servers/desktop_control_server.py"
|
||||
|
||||
print("\n=== Testing Desktop Control Server ===")
|
||||
|
||||
# Test initialize
|
||||
print(" Testing initialize...")
|
||||
success, response, error = send_request(server, {
|
||||
"jsonrpc": "2.0",
|
||||
"id": 1,
|
||||
"method": "initialize",
|
||||
"params": {}
|
||||
})
|
||||
if not success:
|
||||
errors.append(f"initialize failed: {error}")
|
||||
elif "error" in response:
|
||||
errors.append(f"initialize returned error: {response['error']}")
|
||||
else:
|
||||
print(" ✓ initialize works")
|
||||
|
||||
# Test tools/list
|
||||
print(" Testing tools/list...")
|
||||
success, response, error = send_request(server, {
|
||||
"jsonrpc": "2.0",
|
||||
"id": 2,
|
||||
"method": "tools/list",
|
||||
"params": {}
|
||||
})
|
||||
if not success:
|
||||
errors.append(f"tools/list failed: {error}")
|
||||
elif "error" in response:
|
||||
errors.append(f"tools/list returned error: {response['error']}")
|
||||
else:
|
||||
tools = response.get("result", {}).get("tools", [])
|
||||
expected_tools = [
|
||||
"take_screenshot", "get_screen_size", "get_mouse_position",
|
||||
"pixel_color", "click", "right_click", "move_to", "drag_to",
|
||||
"type_text", "press_key", "hotkey", "scroll", "get_os"
|
||||
]
|
||||
tool_names = [t["name"] for t in tools]
|
||||
missing = [t for t in expected_tools if t not in tool_names]
|
||||
if missing:
|
||||
errors.append(f"Missing tools: {missing}")
|
||||
else:
|
||||
print(f" ✓ tools/list works ({len(tools)} tools available)")
|
||||
|
||||
# Test get_os (works without display)
|
||||
print(" Testing tools/call get_os...")
|
||||
success, response, error = send_request(server, {
|
||||
"jsonrpc": "2.0",
|
||||
"id": 3,
|
||||
"method": "tools/call",
|
||||
"params": {"name": "get_os", "arguments": {}}
|
||||
})
|
||||
if not success:
|
||||
errors.append(f"get_os failed: {error}")
|
||||
elif "error" in response:
|
||||
errors.append(f"get_os returned error: {response['error']}")
|
||||
else:
|
||||
content = response.get("result", {}).get("content", [])
|
||||
if content and not response["result"].get("isError"):
|
||||
result_data = json.loads(content[0]["text"])
|
||||
if "system" in result_data:
|
||||
print(f" ✓ get_os works (system: {result_data['system']})")
|
||||
else:
|
||||
errors.append("get_os response missing system info")
|
||||
else:
|
||||
errors.append("get_os returned error content")
|
||||
|
||||
return errors
|
||||
|
||||
|
||||
def test_steam_info_server() -> List[str]:
|
||||
"""Test the Steam info MCP server."""
|
||||
errors = []
|
||||
server = "mcp_servers/steam_info_server.py"
|
||||
|
||||
print("\n=== Testing Steam Info Server ===")
|
||||
|
||||
# Test initialize
|
||||
print(" Testing initialize...")
|
||||
success, response, error = send_request(server, {
|
||||
"jsonrpc": "2.0",
|
||||
"id": 1,
|
||||
"method": "initialize",
|
||||
"params": {}
|
||||
})
|
||||
if not success:
|
||||
errors.append(f"initialize failed: {error}")
|
||||
elif "error" in response:
|
||||
errors.append(f"initialize returned error: {response['error']}")
|
||||
else:
|
||||
print(" ✓ initialize works")
|
||||
|
||||
# Test tools/list
|
||||
print(" Testing tools/list...")
|
||||
success, response, error = send_request(server, {
|
||||
"jsonrpc": "2.0",
|
||||
"id": 2,
|
||||
"method": "tools/list",
|
||||
"params": {}
|
||||
})
|
||||
if not success:
|
||||
errors.append(f"tools/list failed: {error}")
|
||||
elif "error" in response:
|
||||
errors.append(f"tools/list returned error: {response['error']}")
|
||||
else:
|
||||
tools = response.get("result", {}).get("tools", [])
|
||||
expected_tools = [
|
||||
"steam_recently_played", "steam_player_achievements",
|
||||
"steam_user_stats", "steam_current_players", "steam_news",
|
||||
"steam_app_details"
|
||||
]
|
||||
tool_names = [t["name"] for t in tools]
|
||||
missing = [t for t in expected_tools if t not in tool_names]
|
||||
if missing:
|
||||
errors.append(f"Missing tools: {missing}")
|
||||
else:
|
||||
print(f" ✓ tools/list works ({len(tools)} tools available)")
|
||||
|
||||
# Test steam_current_players (mock mode)
|
||||
print(" Testing tools/call steam_current_players...")
|
||||
success, response, error = send_request(server, {
|
||||
"jsonrpc": "2.0",
|
||||
"id": 3,
|
||||
"method": "tools/call",
|
||||
"params": {"name": "steam_current_players", "arguments": {"app_id": "261550"}}
|
||||
})
|
||||
if not success:
|
||||
errors.append(f"steam_current_players failed: {error}")
|
||||
elif "error" in response:
|
||||
errors.append(f"steam_current_players returned error: {response['error']}")
|
||||
else:
|
||||
content = response.get("result", {}).get("content", [])
|
||||
if content and not response["result"].get("isError"):
|
||||
result_data = json.loads(content[0]["text"])
|
||||
if "player_count" in result_data:
|
||||
mode = "mock" if result_data.get("mock") else "live"
|
||||
print(f" ✓ steam_current_players works ({mode} mode, {result_data['player_count']} players)")
|
||||
else:
|
||||
errors.append("steam_current_players response missing player_count")
|
||||
else:
|
||||
errors.append("steam_current_players returned error content")
|
||||
|
||||
# Test steam_recently_played (mock mode)
|
||||
print(" Testing tools/call steam_recently_played...")
|
||||
success, response, error = send_request(server, {
|
||||
"jsonrpc": "2.0",
|
||||
"id": 4,
|
||||
"method": "tools/call",
|
||||
"params": {"name": "steam_recently_played", "arguments": {"user_id": "12345"}}
|
||||
})
|
||||
if not success:
|
||||
errors.append(f"steam_recently_played failed: {error}")
|
||||
elif "error" in response:
|
||||
errors.append(f"steam_recently_played returned error: {response['error']}")
|
||||
else:
|
||||
content = response.get("result", {}).get("content", [])
|
||||
if content and not response["result"].get("isError"):
|
||||
result_data = json.loads(content[0]["text"])
|
||||
if "games" in result_data:
|
||||
print(f" ✓ steam_recently_played works ({len(result_data['games'])} games)")
|
||||
else:
|
||||
errors.append("steam_recently_played response missing games")
|
||||
else:
|
||||
errors.append("steam_recently_played returned error content")
|
||||
|
||||
return errors
|
||||
|
||||
|
||||
def main():
|
||||
"""Run all tests."""
|
||||
print("=" * 60)
|
||||
print("MCP Server Test Suite")
|
||||
print("=" * 60)
|
||||
|
||||
all_errors = []
|
||||
|
||||
all_errors.extend(test_desktop_control_server())
|
||||
all_errors.extend(test_steam_info_server())
|
||||
|
||||
print("\n" + "=" * 60)
|
||||
if all_errors:
|
||||
print(f"FAILED: {len(all_errors)} error(s)")
|
||||
for err in all_errors:
|
||||
print(f" - {err}")
|
||||
sys.exit(1)
|
||||
else:
|
||||
print("ALL TESTS PASSED")
|
||||
print("=" * 60)
|
||||
sys.exit(0)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in New Issue
Block a user