classicchess-mcp 0.1.0__tar.gz

classicchess_mcp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Christian Walls
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

classicchess_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: classicchess-mcp
+Version: 0.1.0
+Summary: Classic Chess stdio MCP client for its hosted study-plan server
+Author: Christian Walls
+License-Expression: MIT
+Project-URL: Homepage, https://classicchess.com/api/
+Project-URL: Documentation, https://classicchess.com/api/docs/integration/#ai-agents
+Project-URL: Download, https://classicchess.com/api/downloads/classicchess-mcp.zip
+Project-URL: Support, https://classicchess.com/support/
+Keywords: chess,mcp,study-plans
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Classic Chess MCP
+
+Connect an assistant to Classic Chess to find games, read PGNs, biographies and
+published annotations, and save study plans with notes and shared progress.
+The hosted MCP URL is `https://classicchess.com/mcp/`.
+
+## Release availability
+
+Version 0.1.0 is a development preview of the relay. The Python package is
+available on PyPI; the hosted MCP endpoint and browser setup guide are awaiting
+the website deployment. Until then, use a local Classic Chess development
+server with `--base-url http://127.0.0.1:PORT`, replacing `PORT` with its port.
+
+## Browser users
+
+Claude and ChatGPT browser users connect to the hosted URL and sign in with
+their own Classic Chess account. Follow the
+[browser setup guide](https://classicchess.com/api/docs/integration/#ai-agents)
+for the current menus, account-plan requirements and workspace permissions.
+Choose automatic OAuth client registration in Claude. ChatGPT's available
+read and write actions depend on its plan and workspace permissions.
+
+Public searches work without account access. Approve library read and write
+access to save plans and read progress. Revoke the connection in Classic Chess
+[Settings](https://classicchess.com/settings/). A Python installation is needed
+only for the optional stdio relay below.
+
+## Claude Code
+
+```sh
+claude mcp add --scope user --transport http classicchess https://classicchess.com/mcp/
+claude mcp login classicchess
+```
+
+Complete browser sign-in and approve library access. Enable Classic Chess in
+a new session and ask, for example: “Build a five-game rook-endgame study plan
+and save it to my account.”
+
+## Codex
+
+```sh
+codex mcp add classicchess --url https://classicchess.com/mcp/
+codex mcp login classicchess --scopes library:read,library:write
+```
+
+Codex may start browser sign-in when adding the server. The login command also
+lets you connect again later. Plans and progress belong to the account you
+approve, and are shared with the Classic Chess website.
+
+## Optional Python stdio relay
+
+This MIT-licensed package needs Python 3.10 or later and has no runtime
+dependencies. It relays newline-delimited MCP messages to the same server.
+Install it from [PyPI](https://pypi.org/project/classicchess-mcp/) into a virtual
+environment.
+
+On Linux or macOS:
+
+```sh
+python3 -m venv classicchess-mcp-env
+classicchess-mcp-env/bin/python -m pip install classicchess-mcp
+classicchess-mcp-env/bin/classicchess-mcp --help
+```
+
+On Windows:
+
+```powershell
+py -m venv classicchess-mcp-env
+classicchess-mcp-env\Scripts\python -m pip install classicchess-mcp
+classicchess-mcp-env\Scripts\classicchess-mcp --help
+```
+
+In a source checkout, install with `python3 -m pip install .` inside your virtual
+environment. The distribution name is `classicchess-mcp`. The
+[website source ZIP](https://classicchess.com/api/downloads/classicchess-mcp.zip)
+will also be available after the website deployment.
+
+Create a personal token in [Settings](https://classicchess.com/settings/) with
+`library:read` and `library:write`, then configure your MCP client's private
+environment:
+
+```json
+{
+  "mcpServers": {
+    "classicchess": {
+      "command": "FULL_PATH_TO_CLASSICCHESS_MCP",
+      "env": {"CLASSICCHESS_API_TOKEN": "YOUR_PERSONAL_TOKEN"}
+    }
+  }
+}
+```
+
+Replace `FULL_PATH_TO_CLASSICCHESS_MCP` with the absolute path to the executable
+in the virtual environment above (`bin/classicchess-mcp` on Linux/macOS,
+`Scripts\classicchess-mcp.exe` on Windows). Replace `YOUR_PERSONAL_TOKEN` only
+in your client's private configuration. Revoke the token in Settings.
+The relay writes only MCP messages to stdout and never prints credentials,
+follows redirects or sends credentials to another origin.
+
+For local development, pass `--base-url http://127.0.0.1:PORT`, replacing `PORT`
+with your development server's port. The canonical HTTPS site and an explicitly
+selected HTTP loopback origin are accepted.
+
+## Tools and protocol
+
+The nine tools are `search_players`, `search_games`, `get_game_pgn`,
+`get_annotations`, `get_player_bio`, `create_plan`, `update_plan`, `mark_studied`
+and `get_progress`. Plan creation accepts 1–100 ordered game slugs and original
+notes. Reuse a stable idempotency key when retrying the same plan. `update_plan`
+performs one operation per call: metadata, reorder, a note, add a game or
+remove an item. Theme rules and evidence are at `/api/v1/public/themes/`.
+
+The server uses stateless Streamable HTTP with JSON responses. It supports
+protocol `2026-07-28` with per-request metadata and bound routing headers, plus
+the initialization flows for `2025-11-25`, `2025-06-18` and `2025-03-26`.
+It publishes OAuth discovery, supports dynamic client registration, requires
+S256 PKCE and accepts native loopback callbacks when the issuer is production
+HTTPS. Clients supporting fixed headers can use personal API tokens instead.
+Source-attributed annotations retain their source and reuse terms.

classicchess_mcp-0.1.0/README.md

@@ -0,0 +1,119 @@
+# Classic Chess MCP
+
+Connect an assistant to Classic Chess to find games, read PGNs, biographies and
+published annotations, and save study plans with notes and shared progress.
+The hosted MCP URL is `https://classicchess.com/mcp/`.
+
+## Release availability
+
+Version 0.1.0 is a development preview of the relay. The Python package is
+available on PyPI; the hosted MCP endpoint and browser setup guide are awaiting
+the website deployment. Until then, use a local Classic Chess development
+server with `--base-url http://127.0.0.1:PORT`, replacing `PORT` with its port.
+
+## Browser users
+
+Claude and ChatGPT browser users connect to the hosted URL and sign in with
+their own Classic Chess account. Follow the
+[browser setup guide](https://classicchess.com/api/docs/integration/#ai-agents)
+for the current menus, account-plan requirements and workspace permissions.
+Choose automatic OAuth client registration in Claude. ChatGPT's available
+read and write actions depend on its plan and workspace permissions.
+
+Public searches work without account access. Approve library read and write
+access to save plans and read progress. Revoke the connection in Classic Chess
+[Settings](https://classicchess.com/settings/). A Python installation is needed
+only for the optional stdio relay below.
+
+## Claude Code
+
+```sh
+claude mcp add --scope user --transport http classicchess https://classicchess.com/mcp/
+claude mcp login classicchess
+```
+
+Complete browser sign-in and approve library access. Enable Classic Chess in
+a new session and ask, for example: “Build a five-game rook-endgame study plan
+and save it to my account.”
+
+## Codex
+
+```sh
+codex mcp add classicchess --url https://classicchess.com/mcp/
+codex mcp login classicchess --scopes library:read,library:write
+```
+
+Codex may start browser sign-in when adding the server. The login command also
+lets you connect again later. Plans and progress belong to the account you
+approve, and are shared with the Classic Chess website.
+
+## Optional Python stdio relay
+
+This MIT-licensed package needs Python 3.10 or later and has no runtime
+dependencies. It relays newline-delimited MCP messages to the same server.
+Install it from [PyPI](https://pypi.org/project/classicchess-mcp/) into a virtual
+environment.
+
+On Linux or macOS:
+
+```sh
+python3 -m venv classicchess-mcp-env
+classicchess-mcp-env/bin/python -m pip install classicchess-mcp
+classicchess-mcp-env/bin/classicchess-mcp --help
+```
+
+On Windows:
+
+```powershell
+py -m venv classicchess-mcp-env
+classicchess-mcp-env\Scripts\python -m pip install classicchess-mcp
+classicchess-mcp-env\Scripts\classicchess-mcp --help
+```
+
+In a source checkout, install with `python3 -m pip install .` inside your virtual
+environment. The distribution name is `classicchess-mcp`. The
+[website source ZIP](https://classicchess.com/api/downloads/classicchess-mcp.zip)
+will also be available after the website deployment.
+
+Create a personal token in [Settings](https://classicchess.com/settings/) with
+`library:read` and `library:write`, then configure your MCP client's private
+environment:
+
+```json
+{
+  "mcpServers": {
+    "classicchess": {
+      "command": "FULL_PATH_TO_CLASSICCHESS_MCP",
+      "env": {"CLASSICCHESS_API_TOKEN": "YOUR_PERSONAL_TOKEN"}
+    }
+  }
+}
+```
+
+Replace `FULL_PATH_TO_CLASSICCHESS_MCP` with the absolute path to the executable
+in the virtual environment above (`bin/classicchess-mcp` on Linux/macOS,
+`Scripts\classicchess-mcp.exe` on Windows). Replace `YOUR_PERSONAL_TOKEN` only
+in your client's private configuration. Revoke the token in Settings.
+The relay writes only MCP messages to stdout and never prints credentials,
+follows redirects or sends credentials to another origin.
+
+For local development, pass `--base-url http://127.0.0.1:PORT`, replacing `PORT`
+with your development server's port. The canonical HTTPS site and an explicitly
+selected HTTP loopback origin are accepted.
+
+## Tools and protocol
+
+The nine tools are `search_players`, `search_games`, `get_game_pgn`,
+`get_annotations`, `get_player_bio`, `create_plan`, `update_plan`, `mark_studied`
+and `get_progress`. Plan creation accepts 1–100 ordered game slugs and original
+notes. Reuse a stable idempotency key when retrying the same plan. `update_plan`
+performs one operation per call: metadata, reorder, a note, add a game or
+remove an item. Theme rules and evidence are at `/api/v1/public/themes/`.
+
+The server uses stateless Streamable HTTP with JSON responses. It supports
+protocol `2026-07-28` with per-request metadata and bound routing headers, plus
+the initialization flows for `2025-11-25`, `2025-06-18` and `2025-03-26`.
+It publishes OAuth discovery, supports dynamic client registration, requires
+S256 PKCE and accepts native loopback callbacks when the issuer is production
+HTTPS. Clients supporting fixed headers can use personal API tokens instead.
+Source-attributed annotations retain their source and reuse terms.

classicchess_mcp-0.1.0/classicchess_mcp/__init__.py

@@ -0,0 +1 @@
+"""Standard-library stdio transport for the Classic Chess hosted MCP server."""

classicchess_mcp-0.1.0/classicchess_mcp/__main__.py

@@ -0,0 +1,138 @@
+"""Relay bounded newline-delimited MCP messages to the authenticated HTTP server."""
+
+import argparse
+import base64
+import json
+import os
+import sys
+from urllib.error import HTTPError
+from urllib.error import URLError
+from urllib.parse import urlsplit
+from urllib.request import HTTPRedirectHandler
+from urllib.request import Request
+from urllib.request import build_opener
+
+MAX_MESSAGE_BYTES = 262144
+MAX_RESPONSE_BYTES = 4194304
+
+
+class NoRedirects(HTTPRedirectHandler):
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        return None
+
+
+def endpoint_for(base_url):
+    """Credentials stay on the canonical site or an explicitly chosen loopback."""
+    try:
+        parsed = urlsplit(base_url)
+        canonical = parsed.scheme == 'https' and parsed.hostname == 'classicchess.com' and parsed.port in (None, 443)
+        local = parsed.scheme == 'http' and parsed.hostname in ('127.0.0.1', 'localhost', '::1')
+        if not (canonical or local) or parsed.username or parsed.password or parsed.query or parsed.fragment or parsed.path not in ('', '/'):
+            raise ValueError
+    except ValueError:
+        raise ValueError('Use https://classicchess.com or an explicit HTTP loopback server.') from None
+    return base_url.rstrip('/') + '/mcp/'
+
+
+def relay(message, *, endpoint, token, protocol='2025-03-26'):
+    body = json.dumps(message, ensure_ascii=False).encode('utf-8')
+    if len(body) > MAX_MESSAGE_BYTES:
+        raise ValueError('Message exceeds 256 KiB.')
+    parameters = message.get('params', {}) if isinstance(message, dict) else {}
+    metadata = parameters.get('_meta', {}) if isinstance(parameters, dict) else {}
+    version = metadata.get('io.modelcontextprotocol/protocolVersion') if isinstance(metadata, dict) else None
+    if version is not None:
+        if not isinstance(version, str) or not version.isascii() or len(version) != 10 or not all(c.isdigit() or c == '-' for c in version):
+            raise ValueError('Invalid protocol metadata.')
+        protocol = version
+    headers = {
+        'Authorization': f'Bearer {token}', 'Content-Type': 'application/json',
+        'Accept': 'application/json, text/event-stream',
+        'MCP-Protocol-Version': protocol,
+        'User-Agent': 'ClassicChess-MCP/0.1',
+    }
+    if version is not None:
+        method = message.get('method', '')
+        if not isinstance(method, str) or not method.isascii() or any(not 33 <= ord(c) <= 126 for c in method):
+            raise ValueError('Invalid method.')
+        headers['Mcp-Method'] = method
+        if method in ('tools/call', 'resources/read', 'prompts/get'):
+            name = parameters.get('name', parameters.get('uri', ''))
+            if not isinstance(name, str):
+                raise ValueError('Invalid tool name.')
+            if name.strip() != name or any(not 32 <= ord(c) <= 126 for c in name) or name.startswith('=?base64?'):
+                name = '=?base64?' + base64.b64encode(name.encode('utf-8')).decode('ascii') + '?='
+            headers['Mcp-Name'] = name
+    request = Request(endpoint, data=body, method='POST', headers=headers)
+    try:
+        with build_opener(NoRedirects()).open(request, timeout=30) as response:
+            data = response.read(MAX_RESPONSE_BYTES + 1)
+            if len(data) > MAX_RESPONSE_BYTES:
+                raise ValueError('Server response exceeds 4 MiB.')
+            if response.status == 202:
+                return None
+            return json.loads(data)
+    except HTTPError as exc:
+        if exc.code in (400, 404) and exc.headers.get_content_type() == 'application/json':
+            try:
+                data = exc.read(MAX_RESPONSE_BYTES + 1)
+                result = json.loads(data) if len(data) <= MAX_RESPONSE_BYTES else None
+                if (isinstance(result, dict) and result.get('jsonrpc') == '2.0'
+                        and result.get('id') == (message.get('id') if isinstance(message, dict) else None) and isinstance(result.get('error'), dict)
+                        and type(result['error'].get('code')) is int):
+                    return result
+            except (ValueError, UnicodeDecodeError, RecursionError):
+                pass
+        # Do not echo headers, credential material, or an untrusted HTML body.
+        retry = exc.headers.get('Retry-After', '')
+        hint = f' Retry after {retry} seconds.' if retry.isdecimal() else ''
+        raise ValueError(f'Server rejected the request (HTTP {exc.code}).{hint}') from None
+    except (URLError, TimeoutError, OSError):
+        raise ValueError('Cannot reach the Classic Chess MCP server.') from None
+
+
+def serve(input_stream, output_stream, *, endpoint, token):
+    protocol = '2025-03-26'
+    while True:
+        line = input_stream.readline(MAX_MESSAGE_BYTES + 1)
+        if not line:
+            return
+        if len(line) > MAX_MESSAGE_BYTES:
+            # Drain the oversized frame instead of executing its suffix.
+            while line and not line.endswith(b'\n'):
+                line = input_stream.readline(MAX_MESSAGE_BYTES + 1)
+            result = {'jsonrpc': '2.0', 'id': None, 'error': {'code': -32600, 'message': 'Message exceeds 256 KiB.'}}
+        else:
+            message = None
+            try:
+                message = json.loads(line)
+                result = relay(message, endpoint=endpoint, token=token, protocol=protocol)
+                if isinstance(result, dict) and isinstance(result.get('result'), dict):
+                    protocol = result['result'].get('protocolVersion', protocol)
+            except (ValueError, UnicodeDecodeError, RecursionError) as exc:
+                identifier = message.get('id') if isinstance(message, dict) else None
+                result = {'jsonrpc': '2.0', 'id': identifier, 'error': {'code': -32603, 'message': str(exc) if message is not None else 'Invalid JSON.'}}
+        if result is not None:
+            output_stream.write(json.dumps(result, ensure_ascii=False) + '\n')
+            output_stream.flush()
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description='Classic Chess stdio MCP transport')
+    parser.add_argument('--base-url', default=os.environ.get('CLASSICCHESS_API_BASE_URL', 'https://classicchess.com'))
+    args = parser.parse_args(argv)
+    token = os.environ.get('CLASSICCHESS_API_TOKEN', '')
+    if not token or len(token) > 256 or not token.isascii() or any(char.isspace() for char in token):
+        print('Set CLASSICCHESS_API_TOKEN to your personal API token.', file=sys.stderr)
+        return 2
+    try:
+        endpoint = endpoint_for(args.base_url)
+    except ValueError as exc:
+        print(str(exc), file=sys.stderr)
+        return 2
+    serve(sys.stdin.buffer, sys.stdout, endpoint=endpoint, token=token)
+    return 0
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())

classicchess_mcp-0.1.0/classicchess_mcp.egg-info/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: classicchess-mcp
+Version: 0.1.0
+Summary: Classic Chess stdio MCP client for its hosted study-plan server
+Author: Christian Walls
+License-Expression: MIT
+Project-URL: Homepage, https://classicchess.com/api/
+Project-URL: Documentation, https://classicchess.com/api/docs/integration/#ai-agents
+Project-URL: Download, https://classicchess.com/api/downloads/classicchess-mcp.zip
+Project-URL: Support, https://classicchess.com/support/
+Keywords: chess,mcp,study-plans
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Classic Chess MCP
+
+Connect an assistant to Classic Chess to find games, read PGNs, biographies and
+published annotations, and save study plans with notes and shared progress.
+The hosted MCP URL is `https://classicchess.com/mcp/`.
+
+## Release availability
+
+Version 0.1.0 is a development preview of the relay. The Python package is
+available on PyPI; the hosted MCP endpoint and browser setup guide are awaiting
+the website deployment. Until then, use a local Classic Chess development
+server with `--base-url http://127.0.0.1:PORT`, replacing `PORT` with its port.
+
+## Browser users
+
+Claude and ChatGPT browser users connect to the hosted URL and sign in with
+their own Classic Chess account. Follow the
+[browser setup guide](https://classicchess.com/api/docs/integration/#ai-agents)
+for the current menus, account-plan requirements and workspace permissions.
+Choose automatic OAuth client registration in Claude. ChatGPT's available
+read and write actions depend on its plan and workspace permissions.
+
+Public searches work without account access. Approve library read and write
+access to save plans and read progress. Revoke the connection in Classic Chess
+[Settings](https://classicchess.com/settings/). A Python installation is needed
+only for the optional stdio relay below.
+
+## Claude Code
+
+```sh
+claude mcp add --scope user --transport http classicchess https://classicchess.com/mcp/
+claude mcp login classicchess
+```
+
+Complete browser sign-in and approve library access. Enable Classic Chess in
+a new session and ask, for example: “Build a five-game rook-endgame study plan
+and save it to my account.”
+
+## Codex
+
+```sh
+codex mcp add classicchess --url https://classicchess.com/mcp/
+codex mcp login classicchess --scopes library:read,library:write
+```
+
+Codex may start browser sign-in when adding the server. The login command also
+lets you connect again later. Plans and progress belong to the account you
+approve, and are shared with the Classic Chess website.
+
+## Optional Python stdio relay
+
+This MIT-licensed package needs Python 3.10 or later and has no runtime
+dependencies. It relays newline-delimited MCP messages to the same server.
+Install it from [PyPI](https://pypi.org/project/classicchess-mcp/) into a virtual
+environment.
+
+On Linux or macOS:
+
+```sh
+python3 -m venv classicchess-mcp-env
+classicchess-mcp-env/bin/python -m pip install classicchess-mcp
+classicchess-mcp-env/bin/classicchess-mcp --help
+```
+
+On Windows:
+
+```powershell
+py -m venv classicchess-mcp-env
+classicchess-mcp-env\Scripts\python -m pip install classicchess-mcp
+classicchess-mcp-env\Scripts\classicchess-mcp --help
+```
+
+In a source checkout, install with `python3 -m pip install .` inside your virtual
+environment. The distribution name is `classicchess-mcp`. The
+[website source ZIP](https://classicchess.com/api/downloads/classicchess-mcp.zip)
+will also be available after the website deployment.
+
+Create a personal token in [Settings](https://classicchess.com/settings/) with
+`library:read` and `library:write`, then configure your MCP client's private
+environment:
+
+```json
+{
+  "mcpServers": {
+    "classicchess": {
+      "command": "FULL_PATH_TO_CLASSICCHESS_MCP",
+      "env": {"CLASSICCHESS_API_TOKEN": "YOUR_PERSONAL_TOKEN"}
+    }
+  }
+}
+```
+
+Replace `FULL_PATH_TO_CLASSICCHESS_MCP` with the absolute path to the executable
+in the virtual environment above (`bin/classicchess-mcp` on Linux/macOS,
+`Scripts\classicchess-mcp.exe` on Windows). Replace `YOUR_PERSONAL_TOKEN` only
+in your client's private configuration. Revoke the token in Settings.
+The relay writes only MCP messages to stdout and never prints credentials,
+follows redirects or sends credentials to another origin.
+
+For local development, pass `--base-url http://127.0.0.1:PORT`, replacing `PORT`
+with your development server's port. The canonical HTTPS site and an explicitly
+selected HTTP loopback origin are accepted.
+
+## Tools and protocol
+
+The nine tools are `search_players`, `search_games`, `get_game_pgn`,
+`get_annotations`, `get_player_bio`, `create_plan`, `update_plan`, `mark_studied`
+and `get_progress`. Plan creation accepts 1–100 ordered game slugs and original
+notes. Reuse a stable idempotency key when retrying the same plan. `update_plan`
+performs one operation per call: metadata, reorder, a note, add a game or
+remove an item. Theme rules and evidence are at `/api/v1/public/themes/`.
+
+The server uses stateless Streamable HTTP with JSON responses. It supports
+protocol `2026-07-28` with per-request metadata and bound routing headers, plus
+the initialization flows for `2025-11-25`, `2025-06-18` and `2025-03-26`.
+It publishes OAuth discovery, supports dynamic client registration, requires
+S256 PKCE and accepts native loopback callbacks when the issuer is production
+HTTPS. Clients supporting fixed headers can use personal API tokens instead.
+Source-attributed annotations retain their source and reuse terms.

classicchess_mcp-0.1.0/classicchess_mcp.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+classicchess_mcp/__init__.py
+classicchess_mcp/__main__.py
+classicchess_mcp.egg-info/PKG-INFO
+classicchess_mcp.egg-info/SOURCES.txt
+classicchess_mcp.egg-info/dependency_links.txt
+classicchess_mcp.egg-info/entry_points.txt
+classicchess_mcp.egg-info/top_level.txt

classicchess_mcp-0.1.0/classicchess_mcp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

classicchess_mcp-0.1.0/classicchess_mcp.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+classicchess-mcp = classicchess_mcp.__main__:main

classicchess_mcp-0.1.0/classicchess_mcp.egg-info/top_level.txt

@@ -0,0 +1 @@
+classicchess_mcp

classicchess_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "classicchess-mcp"
+version = "0.1.0"
+description = "Classic Chess stdio MCP client for its hosted study-plan server"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{name = "Christian Walls"}]
+keywords = ["chess", "mcp", "study-plans"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Operating System :: OS Independent",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://classicchess.com/api/"
+Documentation = "https://classicchess.com/api/docs/integration/#ai-agents"
+Download = "https://classicchess.com/api/downloads/classicchess-mcp.zip"
+Support = "https://classicchess.com/support/"
+
+[project.scripts]
+classicchess-mcp = "classicchess_mcp.__main__:main"
+
+[tool.setuptools]
+packages = ["classicchess_mcp"]

classicchess_mcp-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+