add chess

chess_game/chess_server.py

@@ -0,0 +1,136 @@
+import os
+import random
+from typing import Dict, List, Optional
+
+import chess
+import chess.pgn
+from mcp.server.fastmcp import FastMCP
+
+
+mcp = FastMCP(name="ChessServer", stateless_http=True)
+
+
+# Simple in-memory game state keyed by session_id
+games: Dict[str, Dict] = {}
+
+
+def _get_session_id() -> str:
+    # Provide a default single-session id when not given by client
+    return "default"
+
+
+def _ensure_game(session_id: str) -> Dict:
+    if session_id not in games:
+        games[session_id] = {
+            "board": chess.Board(),
+            "pgn_game": chess.pgn.Game(),
+            "node": None,
+        }
+        games[session_id]["node"] = games[session_id]["pgn_game"]
+    return games[session_id]
+
+
+@mcp.tool(description="Start a new chess game. Returns initial board state.")
+def start_game(session_id: Optional[str] = None, player_color: str = "white") -> Dict:
+    sid = session_id or _get_session_id()
+    game = {
+        "board": chess.Board(),
+        "pgn_game": chess.pgn.Game(),
+        "node": None,
+    }
+    if player_color.lower() not in ("white", "black"):
+        player_color = "white"
+    # If AI should play first (player is black), make an AI opening move
+    if player_color.lower() == "black":
+        # Let engine choose a random legal move
+        ai_move = random.choice(list(game["board"].legal_moves))
+        game["board"].push(ai_move)
+    game["node"] = game["pgn_game"]
+    games[sid] = game
+    return _board_state(game["board"]) | {"session_id": sid, "player_color": player_color}
+
+
+def _board_state(board: chess.Board) -> Dict:
+    return {
+        "fen": board.fen(),
+        "unicode": board.unicode(borders=True),
+        "turn": "white" if board.turn else "black",
+        "is_game_over": board.is_game_over(),
+        "result": board.result() if board.is_game_over() else None,
+        "legal_moves": [board.san(m) for m in board.legal_moves],
+    }
+
+
+@mcp.tool(description="Make a player move in SAN or UCI notation.")
+def player_move(move: str, session_id: Optional[str] = None) -> Dict:
+    sid = session_id or _get_session_id()
+    g = _ensure_game(sid)
+    board: chess.Board = g["board"]
+    try:
+        try:
+            chess_move = board.parse_san(move)
+        except ValueError:
+            chess_move = chess.Move.from_uci(move)
+            if chess_move not in board.legal_moves:
+                raise ValueError("Illegal move")
+        board.push(chess_move)
+        # Update PGN
+        g["node"] = g["node"].add_variation(chess_move)
+        return _board_state(board) | {"last_move": board.san(chess_move)}
+    except Exception as e:
+        return {"error": f"Invalid move: {e}"}
+
+
+@mcp.tool(description="Have the AI make a move (random legal move).")
+def ai_move(session_id: Optional[str] = None) -> Dict:
+    sid = session_id or _get_session_id()
+    g = _ensure_game(sid)
+    board: chess.Board = g["board"]
+    if board.is_game_over():
+        return _board_state(board)
+    move = random.choice(list(board.legal_moves))
+    board.push(move)
+    g["node"] = g["node"].add_variation(move)
+    return _board_state(board) | {"last_move": board.san(move)}
+
+
+@mcp.tool(description="Return current board state.")
+def board(session_id: Optional[str] = None) -> Dict:
+    sid = session_id or _get_session_id()
+    g = _ensure_game(sid)
+    return _board_state(g["board"]) | {"session_id": sid}
+
+
+@mcp.tool(description="List legal moves in SAN notation.")
+def legal_moves(session_id: Optional[str] = None) -> List[str]:
+    sid = session_id or _get_session_id()
+    g = _ensure_game(sid)
+    b: chess.Board = g["board"]
+    return [b.san(m) for m in b.legal_moves]
+
+
+@mcp.tool(description="Game status including check, checkmate, stalemate.")
+def status(session_id: Optional[str] = None) -> Dict:
+    sid = session_id or _get_session_id()
+    g = _ensure_game(sid)
+    b: chess.Board = g["board"]
+    return {
+        "turn": "white" if b.turn else "black",
+        "is_check": b.is_check(),
+        "is_checkmate": b.is_checkmate(),
+        "is_stalemate": b.is_stalemate(),
+        "is_insufficient_material": b.is_insufficient_material(),
+        "is_game_over": b.is_game_over(),
+        "result": b.result() if b.is_game_over() else None,
+    }
+
+
+@mcp.tool(description="Export game PGN.")
+def pgn(session_id: Optional[str] = None) -> str:
+    sid = session_id or _get_session_id()
+    g = _ensure_game(sid)
+    game = g["pgn_game"]
+    exporter = chess.pgn.StringExporter(headers=True, variations=False, comments=False)
+    return game.accept(exporter)
+
+

chess_game/static/style.css

@@ -0,0 +1,12 @@
+body {
+  font-family: system-ui, -apple-system, Segoe UI, Roboto, Ubuntu, Cantarell, Noto Sans, Arial, sans-serif;
+  margin: 0; padding: 0; background: #0b1020; color: #f4f4f8;
+}
+.container { max-width: 900px; margin: 0 auto; padding: 16px; }
+a { color: #93c5fd; text-decoration: none; }
+button { background: #2563eb; color: white; border: 0; padding: 8px 12px; border-radius: 6px; cursor: pointer; }
+button:hover { background: #1d4ed8; }
+input, select { padding: 8px; border-radius: 6px; border: 1px solid #334155; background: #0f172a; color: #e5e7eb; }
+ul { padding-left: 20px; }
+
+

chess_game/templates/index.html

@@ -0,0 +1,47 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Chess Rooms</title>
+  <link rel="stylesheet" href="{{ base_path }}/static/style.css">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <style>
+    pre { white-space: pre-wrap; }
+  </style>
+  <link rel="icon" href="data:,">
+  <meta property="og:title" content="Chess MCP" />
+  <meta property="og:description" content="Play chess against an AI via MCP" />
+  <meta property="og:image" content="/static/embed.png" />
+  <meta name="twitter:card" content="summary_large_image" />
+  <meta name="twitter:title" content="Chess MCP" />
+  <meta name="twitter:description" content="Play chess against an AI via MCP" />
+  <meta name="twitter:image" content="/static/embed.png" />
+  <meta name="robots" content="noai" />
+  <meta name="ai-access-control" content="none" />
+</head>
+<body>
+  <div class="container">
+    <h1>Chess MCP Rooms</h1>
+    <form method="post" action="{{ base_path }}/create_room">
+      <button type="submit">Create Room</button>
+    </form>
+
+    <h2>Join Room</h2>
+    <form onsubmit="event.preventDefault(); location.href='{{ base_path }}/room/' + document.getElementById('rid').value;">
+      <input id="rid" placeholder="Enter room id" required />
+      <button type="submit">Join</button>
+    </form>
+
+    <h2>Active Rooms</h2>
+    <ul>
+      {% for rid, info in rooms.items() %}
+        <li><a href="{{ base_path }}/room/{{ rid }}">{{ rid }}</a></li>
+      {% else %}
+        <li>No rooms yet. Create one!</li>
+      {% endfor %}
+    </ul>
+  </div>
+</body>
+</html>
+
+

chess_game/templates/room.html

@@ -0,0 +1,94 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Chess Room {{ room_id }}</title>
+  <link rel="stylesheet" href="{{ base_path }}/static/style.css">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <style>
+    pre.board { font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace; font-size: 14px; line-height: 1.2; }
+    .controls { display: flex; gap: 8px; flex-wrap: wrap; margin: 8px 0; }
+    .status { margin-top: 8px; }
+  </style>
+  <link rel="icon" href="data:,">
+</head>
+<body>
+  <div class="container">
+    <a href="{{ base_path }}/">← Back</a>
+    <h1>Room: {{ room_id }}</h1>
+
+    <div class="controls">
+      <select id="color">
+        <option value="white">White</option>
+        <option value="black">Black</option>
+      </select>
+      <button id="startBtn">Start / Reset</button>
+      <input id="moveInput" placeholder="Enter SAN or UCI (e4, Nf3, e7e5)" />
+      <button id="moveBtn">Make Move</button>
+      <button id="aiBtn">AI Move</button>
+      <button id="copyPgnBtn">Copy PGN</button>
+    </div>
+
+    <pre id="board" class="board">{{ state.unicode }}</pre>
+    <div class="status">
+      <div><strong>Turn:</strong> <span id="turn"></span></div>
+      <div><strong>Result:</strong> <span id="result"></span></div>
+      <div><strong>Legal Moves:</strong> <span id="legal"></span></div>
+    </div>
+  </div>
+
+  <script>
+    const roomId = {{ room_id | tojson }};
+    const basePath = {{ base_path | tojson }};
+
+    async function getJSON(path, options) {
+      const res = await fetch(path, options);
+      if (!res.ok) {
+        const msg = await res.text();
+        throw new Error(msg || res.statusText);
+      }
+      return res.json();
+    }
+
+    async function refresh() {
+      const state = await getJSON(`${basePath}/room/${roomId}/board`);
+      document.getElementById('board').textContent = state.unicode;
+      const s = await getJSON(`${basePath}/room/${roomId}/status`);
+      document.getElementById('turn').textContent = s.turn + (s.is_check ? ' (check)' : '');
+      document.getElementById('result').textContent = s.is_game_over ? (s.result || 'game over') : '-';
+      const legal = await getJSON(`${basePath}/room/${roomId}/legal_moves`);
+      document.getElementById('legal').textContent = legal.join(', ');
+    }
+
+    document.getElementById('startBtn').addEventListener('click', async () => {
+      const color = document.getElementById('color').value;
+      await getJSON(`${basePath}/room/${roomId}/start`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ player_color: color })});
+      await refresh();
+    });
+
+    document.getElementById('moveBtn').addEventListener('click', async () => {
+      const mv = document.getElementById('moveInput').value.trim();
+      if (!mv) return;
+      try {
+        await getJSON(`${basePath}/room/${roomId}/player_move`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ move: mv })});
+      } catch (e) { alert('Move error: ' + e.message); }
+      await refresh();
+    });
+
+    document.getElementById('aiBtn').addEventListener('click', async () => {
+      await getJSON(`${basePath}/room/${roomId}/ai_move`, { method: 'POST' });
+      await refresh();
+    });
+
+    document.getElementById('copyPgnBtn').addEventListener('click', async () => {
+      const data = await getJSON(`${basePath}/room/${roomId}/pgn`);
+      await navigator.clipboard.writeText(data.pgn || '');
+      alert('PGN copied to clipboard');
+    });
+
+    refresh();
+  </script>
+</body>
+</html>
+
+

chess_game/web_app.py

@@ -0,0 +1,99 @@
+import os
+import uuid
+
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+
+from .chess_server import start_game as m_start_game, player_move as m_player_move, ai_move as m_ai_move, board as m_board, legal_moves as m_legal_moves, status as m_status, pgn as m_pgn
+
+
+BASE_DIR = os.path.dirname(__file__)
+TEMPLATES_DIR = os.path.join(BASE_DIR, "templates")
+STATIC_DIR = os.path.join(BASE_DIR, "static")
+
+
+app = FastAPI()
+app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
+templates = Jinja2Templates(directory=TEMPLATES_DIR)
+
+
+# Simple room registry for UI convenience (MCP state keyed by room_id in chess_server)
+rooms = {}
+
+
+def generate_room_id() -> str:
+    return uuid.uuid4().hex[:8]
+
+
+@app.get("/", response_class=HTMLResponse)
+def home(request: Request):
+    base_path = request.scope.get('root_path', '')
+    return templates.TemplateResponse("index.html", {"request": request, "rooms": rooms, "base_path": base_path})
+
+
+@app.post("/create_room")
+def create_room(request: Request):
+    # Choose a new room id and redirect to room page; player picks color there
+    room_id = generate_room_id()
+    rooms[room_id] = {"id": room_id}
+    return RedirectResponse(url=f"{request.scope.get('root_path', '')}/room/{room_id}", status_code=303)
+
+
+@app.get("/room/{room_id}", response_class=HTMLResponse)
+def room_page(room_id: str, request: Request):
+    base_path = request.scope.get('root_path', '')
+    # Fetch board (this also ensures MCP game exists lazily)
+    state = m_board(session_id=room_id)
+    if room_id not in rooms:
+        rooms[room_id] = {"id": room_id}
+    return templates.TemplateResponse("room.html", {"request": request, "room_id": room_id, "state": state, "base_path": base_path})
+
+
+# --- API: Map to MCP tools ---
+
+
+@app.post("/room/{room_id}/start")
+def api_start(room_id: str, payload: dict | None = None):
+    player_color = (payload or {}).get("player_color", "white")
+    state = m_start_game(session_id=room_id, player_color=player_color)
+    return JSONResponse(state)
+
+
+@app.post("/room/{room_id}/player_move")
+def api_player_move(room_id: str, payload: dict):
+    if not payload or "move" not in payload:
+        raise HTTPException(status_code=400, detail="Missing 'move' in body")
+    result = m_player_move(move=payload["move"], session_id=room_id)
+    if "error" in result:
+        raise HTTPException(status_code=400, detail=result["error"])
+    return JSONResponse(result)
+
+
+@app.post("/room/{room_id}/ai_move")
+def api_ai_move(room_id: str):
+    result = m_ai_move(session_id=room_id)
+    return JSONResponse(result)
+
+
+@app.get("/room/{room_id}/board")
+def api_board(room_id: str):
+    return JSONResponse(m_board(session_id=room_id))
+
+
+@app.get("/room/{room_id}/legal_moves")
+def api_legal_moves(room_id: str):
+    return JSONResponse(m_legal_moves(session_id=room_id))
+
+
+@app.get("/room/{room_id}/status")
+def api_status(room_id: str):
+    return JSONResponse(m_status(session_id=room_id))
+
+
+@app.get("/room/{room_id}/pgn")
+def api_pgn(room_id: str):
+    return JSONResponse({"pgn": m_pgn(session_id=room_id)})
+
+

requirements.txt

@@ -4,4 +4,5 @@ pydantic>=2.7.0
 selectolax>=0.3.15 
 fastapi
 jinja2
-Pillow
+Pillow
+python-chess>=1.999

server.py

@@ -5,7 +5,9 @@ from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
 from pokemon.pokemon_server import mcp as pokemon_mcp
 from geoguessr.geo_server import mcp as geogussr_mcp
+from chess_game.chess_server import mcp as chess_mcp
 from geoguessr.web_app import app as geoguessr_app
+from chess_game.web_app import app as chess_app
 import os
 
 
@@ -15,6 +17,7 @@ async def lifespan(app: FastAPI):
     async with contextlib.AsyncExitStack() as stack:
         await stack.enter_async_context(pokemon_mcp.session_manager.run())
         await stack.enter_async_context(geogussr_mcp.session_manager.run())
+        await stack.enter_async_context(chess_mcp.session_manager.run())
         yield
 
 
@@ -42,9 +45,11 @@ async def index(request: Request):
 
 app.mount("/geoguessr", geogussr_mcp.streamable_http_app())
 app.mount("/Pokemon", pokemon_mcp.streamable_http_app())
+app.mount("/chess", chess_mcp.streamable_http_app())
 
 # Mount GeoGuessr FastAPI web app (UI + API)
 app.mount("/geoguessr_app", geoguessr_app)
+app.mount("/chess_app", chess_app)
 
 PORT = int(os.environ.get("PORT", "10000"))