aidlc.html-creator-mcp 1.0.0__tar.gz

aidlc_html_creator_mcp-1.0.0/.gitignore

@@ -0,0 +1,26 @@
+.venv/
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.ruff_cache/
+*.egg-info/
+build/
+dist/
+.aws-sam/
+samconfig.local.toml
+.DS_Store
+.env
+.env.*
+!.env.example
+*.pem
+*.key
+
+# Generated per environment by deploy/publish-admin.sh from the stack outputs, and uploaded
+# straight to the site bucket. Committing it would mean a file that is wrong for every
+# environment but the one it was written for. admin-ui/public/config.sample.json documents the
+# shape. The script now writes it to a temp directory, so this only catches a hand-made copy.
+admin-ui/public/config.json
+
+# Scratch screenshots from driving the admin console in a browser during review. Evidence for
+# one session, not part of the repo.
+.tmp-shots/

aidlc_html_creator_mcp-1.0.0/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.5
+Name: aidlc.html-creator-mcp
+Version: 1.0.0
+Summary: Connects an MCP client over stdio to the html-creator assessment site workflow, hosted by the MSC Labs CoE.
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# aidlc.html-creator-mcp
+
+Connects an MCP client to the html-creator assessment site workflow, which runs in the MSC Labs CoE account. The workflow, its
+guardrails and its policy live there; this package is only the stdio bridge.
+
+## Configure
+
+Track the latest release:
+
+```json
+{
+  "mcpServers": {
+    "aidlc.html-creator": {
+      "command": "uvx",
+      "args": ["aidlc.html-creator-mcp@latest"],
+      "env": { "MCP_API_TOKEN": "${MCP_API_TOKEN}" }
+    }
+  }
+}
+```
+
+Or pin one, so a new release reaches your machine only when you change the number:
+
+```json
+"args": ["aidlc.html-creator-mcp==1.0.0"]
+```
+
+Set `MCP_API_TOKEN` to the key the CoE issued you, and add `MCP_API_TOKEN` to your client's
+approved environment variables. Without a key the registry answers 403 and nothing works.
+
+## What it does not do
+
+It holds no copy of the workflow, caches nothing and decides nothing. Every step, reference and
+policy check is answered by the hosted server at call time, so what you run is always what the
+CoE published.
+
+| Variable | Default | Purpose |
+| --- | --- | --- |
+| `MCP_API_TOKEN` | — | Your API key. Required. |
+| `MSCLABS_MCP_BASE_URL` | the CoE endpoint | Point at a different deployment. |
+| `MSCLABS_MCP_TIMEOUT` | `120` | Seconds to wait for one call. |

aidlc_html_creator_mcp-1.0.0/README.md

@@ -0,0 +1,41 @@
+# aidlc.html-creator-mcp
+
+Connects an MCP client to the html-creator assessment site workflow, which runs in the MSC Labs CoE account. The workflow, its
+guardrails and its policy live there; this package is only the stdio bridge.
+
+## Configure
+
+Track the latest release:
+
+```json
+{
+  "mcpServers": {
+    "aidlc.html-creator": {
+      "command": "uvx",
+      "args": ["aidlc.html-creator-mcp@latest"],
+      "env": { "MCP_API_TOKEN": "${MCP_API_TOKEN}" }
+    }
+  }
+}
+```
+
+Or pin one, so a new release reaches your machine only when you change the number:
+
+```json
+"args": ["aidlc.html-creator-mcp==1.0.0"]
+```
+
+Set `MCP_API_TOKEN` to the key the CoE issued you, and add `MCP_API_TOKEN` to your client's
+approved environment variables. Without a key the registry answers 403 and nothing works.
+
+## What it does not do
+
+It holds no copy of the workflow, caches nothing and decides nothing. Every step, reference and
+policy check is answered by the hosted server at call time, so what you run is always what the
+CoE published.
+
+| Variable | Default | Purpose |
+| --- | --- | --- |
+| `MCP_API_TOKEN` | — | Your API key. Required. |
+| `MSCLABS_MCP_BASE_URL` | the CoE endpoint | Point at a different deployment. |
+| `MSCLABS_MCP_TIMEOUT` | `120` | Seconds to wait for one call. |

aidlc_html_creator_mcp-1.0.0/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "aidlc.html-creator-mcp"
+version = "1.0.0"
+description = "Connects an MCP client over stdio to the html-creator assessment site workflow, hosted by the MSC Labs CoE."
+readme = "README.md"
+requires-python = ">=3.10"
+# The standard library only, on purpose: nothing third-party should ever see the API key, and
+# `uvx` start-up stays the download of one small wheel.
+dependencies = []
+
+[project.scripts]
+"aidlc.html-creator-mcp" = "aidlc_html_creator_mcp.bridge:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/aidlc_html_creator_mcp"]

aidlc_html_creator_mcp-1.0.0/src/aidlc_html_creator_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""stdio bridge to aidlc.html-creator, hosted by the MSC Labs CoE."""
+
+__version__ = "1.0.0"

aidlc_html_creator_mcp-1.0.0/src/aidlc_html_creator_mcp/__main__.py

@@ -0,0 +1,5 @@
+"""`python -m aidlc_html_creator_mcp`, for a client that would rather run a module than a script."""
+
+from .bridge import main
+
+raise SystemExit(main())

aidlc_html_creator_mcp-1.0.0/src/aidlc_html_creator_mcp/bridge.py

@@ -0,0 +1,130 @@
+"""stdio to the hosted registry, and nothing else.
+
+This is the only piece of the registry that runs on a developer's machine, so it is kept as
+close to empty as a working program can be: it reads a JSON-RPC line from stdin, posts it to
+the hosted server with the developer's API key, and writes the reply back to stdout. There is
+no procedure here, no policy, no cached content and no state — those stay server-side, which is
+the whole reason the registry is hosted rather than installed. A developer can read every line
+of this file and find nothing to tune.
+
+It depends on the standard library alone. That keeps `uvx` start-up to the download of one
+small wheel, and keeps the API key out of reach of any third-party package.
+
+Posting a line and reading the reply is enough because the hosted servers run in stateless JSON
+mode: one request, one response, no session to keep alive and no event stream to multiplex.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import urllib.error
+import urllib.request
+
+#: Filled in per distribution by the generator in `build_clients.py`.
+SERVER_ID = "html-creator"
+SERVER_NAME = "aidlc.html-creator"
+BASE_URL = "https://8a3gpe2ji0.execute-api.ap-southeast-7.amazonaws.com/v1"
+VERSION = "1.0.0"
+
+TOKEN_VARS = ("MCP_API_TOKEN", "MSCLABS_MCP_TOKEN")
+TIMEOUT = float(os.environ.get("MSCLABS_MCP_TIMEOUT", "120"))
+
+
+def _log(message: str) -> None:
+    """Diagnostics go to stderr. stdout carries the protocol and nothing else."""
+    print(f"[{SERVER_NAME}] {message}", file=sys.stderr, flush=True)
+
+
+def _token() -> str:
+    for name in TOKEN_VARS:
+        value = os.environ.get(name, "").strip()
+        if value:
+            return value
+    _log(
+        "No API key. Set MCP_API_TOKEN to the key the CoE issued you, and add MCP_API_TOKEN to "
+        "your client's approved environment variables. Ask the CoE for a key if you have none."
+    )
+    raise SystemExit(2)
+
+
+def _endpoint() -> str:
+    base = os.environ.get("MSCLABS_MCP_BASE_URL", BASE_URL).rstrip("/")
+    return f"{base}/{SERVER_ID}/mcp"
+
+
+def _error(request_id: object, code: int, message: str) -> str:
+    return json.dumps({"jsonrpc": "2.0", "id": request_id, "error": {"code": code, "message": message}})
+
+
+def _forward(url: str, token: str, line: str, request_id: object) -> str | None:
+    """Posts one message upstream and returns the reply to write to stdout, if any."""
+    request = urllib.request.Request(url, data=line.encode(), method="POST")
+    request.add_header("Content-Type", "application/json")
+    request.add_header("Accept", "application/json, text/event-stream")
+    request.add_header("x-api-key", token)
+    request.add_header("User-Agent", f"{SERVER_NAME}/{VERSION}")
+    try:
+        with urllib.request.urlopen(request, timeout=TIMEOUT) as response:
+            body = response.read().decode(errors="replace")
+    except urllib.error.HTTPError as exc:
+        detail = exc.read().decode(errors="replace")[:400]
+        if exc.code in (401, 403):
+            # The most common failure by far, and the one whose default message sends people
+            # looking in the wrong place: the client reports an OAuth problem when the real
+            # cause is a key that is missing, mistyped or revoked.
+            _log(
+                f"{exc.code} from the registry: the API key was rejected. Check MCP_API_TOKEN is "
+                "the whole key, that your client is allowed to pass it through, and that the key "
+                "has not been revoked."
+            )
+        else:
+            _log(f"{exc.code} from the registry: {detail}")
+        if request_id is None:
+            return None
+        return _error(request_id, -32000, f"registry returned HTTP {exc.code}")
+    except Exception as exc:  # noqa: BLE001 - any transport failure becomes one JSON-RPC error
+        _log(f"could not reach the registry: {exc}")
+        if request_id is None:
+            return None
+        return _error(request_id, -32000, f"could not reach the registry: {exc}")
+
+    if request_id is None:
+        # A notification gets no reply, and writing one would desynchronise the client.
+        return None
+    # Stateless JSON mode answers with a JSON object; an SSE frame is still accepted in case a
+    # future deployment negotiates one.
+    for candidate in body.splitlines():
+        candidate = candidate.removeprefix("data:").strip()
+        if candidate.startswith("{"):
+            return candidate
+    return _error(request_id, -32000, "the registry returned an empty response")
+
+
+def main() -> int:
+    token = _token()
+    url = _endpoint()
+    _log(f"bridging stdio to {url}")
+
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            message = json.loads(line)
+        except json.JSONDecodeError:
+            sys.stdout.write(_error(None, -32700, "parse error") + "\n")
+            sys.stdout.flush()
+            continue
+
+        request_id = message.get("id") if isinstance(message, dict) else None
+        reply = _forward(url, token, line, request_id)
+        if reply is not None:
+            sys.stdout.write(reply + "\n")
+            sys.stdout.flush()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())