mcp-as-code 0.1.2__tar.gz → 0.1.4__tar.gz

mcp_as_code-0.1.4/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: mcp-as-code
+Version: 0.1.4
+Summary: Execute MCP tools through generated Python code interfaces
+License-Expression: Apache-2.0
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: jinja2>=3.1
+Requires-Dist: matchlock==0.2.15
+Requires-Dist: mcp>=1.24.0
+Requires-Dist: pydantic>=2.0
+Description-Content-Type: text/markdown
+
+# maco
+
+**Connect every MCP server you need, keeping your agent's context lean.**
+
+As the number of MCP servers you connect grows, tool schemas and intermediate tool call results clutter your agent's context. `maco` (mcp-as-code) collapses them all into a single endpoint with a programmatic interface.
+
+Instead of loading hundreds if not thousands of tool schemas upfront, `maco` reconstructs every MCP tool as Pydantic models and Python functions in a virtual filesystem and hands your agent just two of its favourite tools: `bash` to navigate, and `code_execute` to run. The agent discovers and composes tools as code, the thing frontier models do best.
+
+## How it works
+
+**Small context footprint:** the agent starts with two tools (`bash` and `code_execute`), not every MCP tool schema upfront.
+
+**Progressive discovery:** frontier models excel at navigating filesystems. By representing the tool interface as code on a filesystem, the agent can leverage `rg`, `fd` and all the POSIX tools to discover and execute relevant MCP tools.
+
+```bash
+tools
+├── playwright
+│   ├── browserClick.py
+│   ├── browserClose.py
+│   ├── ... many other tools
+│   └── __init__.py
+└── github
+    ├── addIssueComment.py
+    └── __init__.py
+```
+
+**Programmatic leverage:** the agent is given a real programming language, Python, allowing it to orchestrate complex control flows with exceptional context-efficiency using loops, conditions, and state management.
+
+```python
+from collections import Counter
+from tools.github import listCommits
+
+owner, repo, page, counts = "openclaw", "openclaw", 1, Counter()
+
+while True:
+    commits = listCommits(owner=owner, repo=repo, perPage=100, page=page)
+    for commit in commits:
+        login = (commit.get("author") or {}).get("login")
+        if login and "bot" not in login.lower():
+            counts[login] += 1
+    if len(commits) < 100 or page >= 20:
+        break
+    page += 1
+
+total = sum(counts.values())
+for login, count in counts.most_common():
+    if count / total < 0.01:
+        break
+    print(f"@{login}: {count} commits ({count / total:.1%})")
+```
+
+The example above illustrates the MCP code that will be executed to find the top contributors to an open-source repository.
+
+## Installation
+
+Install the Python package `mcp-as-code`; it provides the `maco` executable:
+
+```bash
+uv tool install mcp-as-code
+```
+
+Then verify the CLI:
+
+```bash
+maco version
+```
+
+## Quick start
+
+Create a `mcp.json`:
+
+```json
+{
+    "mcpServers": {
+        "playwright": {
+            "command": "npx",
+            "args": ["-y", "@playwright/mcp@latest"]
+        },
+        "github": {
+            "url": "https://api.githubcopilot.com/mcp/",
+            "headers": { "Authorization": "Bearer ${GITHUB_TOKEN}" }
+        }
+    }
+}
+```
+
+This config needs `npx` (for Playwright MCP), a GitHub token in `GITHUB_TOKEN`, and Docker if you use the `docker` provider.
+
+Start the `maco` MCP server:
+
+```bash
+maco serve-mcp --config mcp.json --provider docker
+```
+
+Use `--provider local` for a faster, non-isolated local feedback loop.
+
+By default this serves Streamable HTTP MCP at `http://127.0.0.1:8789/mcp`.
+
+Configure an MCP client to connect to that endpoint:
+
+<details>
+<summary>Codex</summary>
+
+```bash
+codex mcp add maco --url http://127.0.0.1:8789/mcp
+```
+
+</details>
+
+<details>
+<summary>Claude Code</summary>
+
+```bash
+claude mcp add --transport http maco http://127.0.0.1:8789/mcp
+```
+
+</details>
+
+See [`examples/serve-mcp`](examples/serve-mcp) for a complete example that wraps multiple upstream MCP servers behind one `maco` endpoint.
+
+## MCP config
+
+See [`docs/mcp-config.md`](docs/mcp-config.md) for the full config reference, including environment expansion, headers, OAuth hints, token caching, and tool filtering.
+
+## Sandbox providers
+
+Choose the execution provider with `--provider`:
+
+- `local`: fastest feedback loop; runs commands as local subprocesses.
+- `docker`: runs commands in a long-lived Docker container.
+- `matchlock`: runs commands in a long-lived Matchlock micro-VM.
+
+## License
+
+Apache License 2.0. See [`LICENSE`](LICENSE).

mcp_as_code-0.1.4/README.md

@@ -0,0 +1,135 @@
+# maco
+
+**Connect every MCP server you need, keeping your agent's context lean.**
+
+As the number of MCP servers you connect grows, tool schemas and intermediate tool call results clutter your agent's context. `maco` (mcp-as-code) collapses them all into a single endpoint with a programmatic interface.
+
+Instead of loading hundreds if not thousands of tool schemas upfront, `maco` reconstructs every MCP tool as Pydantic models and Python functions in a virtual filesystem and hands your agent just two of its favourite tools: `bash` to navigate, and `code_execute` to run. The agent discovers and composes tools as code, the thing frontier models do best.
+
+## How it works
+
+**Small context footprint:** the agent starts with two tools (`bash` and `code_execute`), not every MCP tool schema upfront.
+
+**Progressive discovery:** frontier models excel at navigating filesystems. By representing the tool interface as code on a filesystem, the agent can leverage `rg`, `fd` and all the POSIX tools to discover and execute relevant MCP tools.
+
+```bash
+tools
+├── playwright
+│   ├── browserClick.py
+│   ├── browserClose.py
+│   ├── ... many other tools
+│   └── __init__.py
+└── github
+    ├── addIssueComment.py
+    └── __init__.py
+```
+
+**Programmatic leverage:** the agent is given a real programming language, Python, allowing it to orchestrate complex control flows with exceptional context-efficiency using loops, conditions, and state management.
+
+```python
+from collections import Counter
+from tools.github import listCommits
+
+owner, repo, page, counts = "openclaw", "openclaw", 1, Counter()
+
+while True:
+    commits = listCommits(owner=owner, repo=repo, perPage=100, page=page)
+    for commit in commits:
+        login = (commit.get("author") or {}).get("login")
+        if login and "bot" not in login.lower():
+            counts[login] += 1
+    if len(commits) < 100 or page >= 20:
+        break
+    page += 1
+
+total = sum(counts.values())
+for login, count in counts.most_common():
+    if count / total < 0.01:
+        break
+    print(f"@{login}: {count} commits ({count / total:.1%})")
+```
+
+The example above illustrates the MCP code that will be executed to find the top contributors to an open-source repository.
+
+## Installation
+
+Install the Python package `mcp-as-code`; it provides the `maco` executable:
+
+```bash
+uv tool install mcp-as-code
+```
+
+Then verify the CLI:
+
+```bash
+maco version
+```
+
+## Quick start
+
+Create a `mcp.json`:
+
+```json
+{
+    "mcpServers": {
+        "playwright": {
+            "command": "npx",
+            "args": ["-y", "@playwright/mcp@latest"]
+        },
+        "github": {
+            "url": "https://api.githubcopilot.com/mcp/",
+            "headers": { "Authorization": "Bearer ${GITHUB_TOKEN}" }
+        }
+    }
+}
+```
+
+This config needs `npx` (for Playwright MCP), a GitHub token in `GITHUB_TOKEN`, and Docker if you use the `docker` provider.
+
+Start the `maco` MCP server:
+
+```bash
+maco serve-mcp --config mcp.json --provider docker
+```
+
+Use `--provider local` for a faster, non-isolated local feedback loop.
+
+By default this serves Streamable HTTP MCP at `http://127.0.0.1:8789/mcp`.
+
+Configure an MCP client to connect to that endpoint:
+
+<details>
+<summary>Codex</summary>
+
+```bash
+codex mcp add maco --url http://127.0.0.1:8789/mcp
+```
+
+</details>
+
+<details>
+<summary>Claude Code</summary>
+
+```bash
+claude mcp add --transport http maco http://127.0.0.1:8789/mcp
+```
+
+</details>
+
+See [`examples/serve-mcp`](examples/serve-mcp) for a complete example that wraps multiple upstream MCP servers behind one `maco` endpoint.
+
+## MCP config
+
+See [`docs/mcp-config.md`](docs/mcp-config.md) for the full config reference, including environment expansion, headers, OAuth hints, token caching, and tool filtering.
+
+## Sandbox providers
+
+Choose the execution provider with `--provider`:
+
+- `local`: fastest feedback loop; runs commands as local subprocesses.
+- `docker`: runs commands in a long-lived Docker container.
+- `matchlock`: runs commands in a long-lived Matchlock micro-VM.
+
+## License
+
+Apache License 2.0. See [`LICENSE`](LICENSE).

mcp_as_code-0.1.4/VERSION.txt

@@ -0,0 +1 @@
+0.1.4

mcp_as_code-0.1.4/examples/serve-mcp/README.md

@@ -0,0 +1,41 @@
+# `maco serve-mcp` example
+
+This example shows how to expose several upstream MCP servers through one compact `maco serve-mcp` endpoint. The upstream servers here are:
+
+- [Playwright MCP](https://playwright.dev/mcp/introduction), launched with `npx -y @playwright/mcp@latest`
+- [GitHub MCP server](https://github.com/github/github-mcp-server), using GitHub's hosted Streamable HTTP endpoint at `https://api.githubcopilot.com/mcp/`
+
+## Prerequisites
+
+- `uv`
+- `node`/`npx`, for Playwright MCP
+- A GitHub personal access token in `GITHUB_TOKEN`, used by the hosted GitHub MCP server
+- Docker, only if you use the Docker sandbox provider
+- Optional: Matchlock, for the Matchlock sandbox provider
+
+If you are already authenticated with the GitHub CLI, export a token directly:
+
+```bash
+export GITHUB_TOKEN=$(gh auth token)
+```
+
+## 1. Start `maco serve-mcp`
+
+The short path is to run from this example directory so the defaults line up with the local files:
+
+```bash
+cd examples/serve-mcp
+uv run maco serve-mcp --provider local
+```
+
+This uses `mcp.json`, writes `.maco/gateway.json`, uses `maco-serve-mcp/` as scratch, starts the gateway, and serves HTTP MCP at `http://127.0.0.1:8789/mcp`. Add `--clean` only when you want to recreate the local generated SDK from scratch.
+
+## 2. Connect an agent to the MCP gateway
+
+Configure your MCP client with `mcp-client.json` to connect to `maco serve-mcp`. For example, in your MCP client's settings, set the MCP server URL to `http://127.0.0.1:8789/mcp`.
+
+If you are using codex you may connect to it via:
+
+```bash
+codex mcp add maco --url http://127.0.0.1:8789/mcp
+```

mcp_as_code-0.1.4/src/maco/_build_info.py

@@ -0,0 +1,4 @@
+"""Build metadata embedded during release builds."""
+
+COMMIT_SHA = "b592f828ae0d4766fbeff34d47d0b10e6f4158e1"
+RELEASE_DATE = "2026-06-16"

mcp_as_code-0.1.2/PKG-INFO

@@ -1,202 +0,0 @@
-Metadata-Version: 2.4
-Name: mcp-as-code
-Version: 0.1.2
-Summary: Execute MCP tools through generated Python code interfaces
-License-Expression: Apache-2.0
-License-File: LICENSE
-Requires-Python: >=3.11
-Requires-Dist: jinja2>=3.1
-Requires-Dist: matchlock==0.2.15
-Requires-Dist: mcp>=1.24.0
-Requires-Dist: pydantic>=2.0
-Description-Content-Type: text/markdown
-
-# maco
-
-`maco` (mcp-as-code) lets an MCP client interact with many upstream MCP tools through a small code-execution interface.
-
-It follows Anthropic's [code-execution-with-MCP pattern](https://www.anthropic.com/engineering/code-execution-with-mcp): keep the large MCP surface area behind a gateway, then let agents write short Python programs for loops, filtering, joins, retries, and structured output. Instead of loading hundreds of tool schemas into the context window, the client gets a compact interface for shell discovery and Python execution.
-
-## At a glance
-
-- Point `maco` at a Claude-style `mcp.json` containing one or many MCP servers.
-- Run `maco serve-mcp` to expose one Streamable HTTP MCP endpoint.
-- Connect your MCP client to that endpoint; it sees only `bash` and `code_execute`.
-- Agents thrive on discovery with `rg` and `fd`, so maco gives them `bash` access to navigate the tool interface as a real filesystem.
-- Use `code_execute` to call upstream MCP tools from Python with `from tools.<server> import <tool>`.
-
-## Why it helps
-
-- **Small context footprint:** the client starts with two tools, not every upstream schema.
-- **Programmatic leverage:** use Python for paging, filtering, joining, caching, retries, and local intermediate files.
-- **Progressive discovery:** inspect only the generated wrappers relevant to the task.
-- **Flexible isolation:** run code locally for fast iteration or inside Docker/Matchlock for stronger isolation.
-- **Works with existing MCP servers:** stdio, Streamable HTTP, and SSE server configs are supported.
-
-## How it works
-
-```text
-MCP client
-    │ sees only bash + code_execute
-    ▼
-maco serve-mcp  ── sandbox ──▶ Python code imports generated tools
-    │
-    ▼
-managed maco gateway
-    │
-    ▼
-upstream MCP servers from mcp.json
-```
-
-`maco serve-mcp` starts a managed gateway for the upstream MCP servers, prepares a generated Python SDK for the sandbox, and serves a compact MCP endpoint for downstream clients.
-
-## Installation
-
-Install the Python package `mcp-as-code`; it provides the `maco` executable:
-
-```bash
-uv tool install mcp-as-code
-```
-
-Then verify the CLI:
-
-```bash
-maco version
-```
-
-## Quick start
-
-Create a Claude-style `mcp.json`:
-
-```json
-{
-  "mcpServers": {
-    "filesystem": {
-      "command": "npx",
-      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
-    }
-  }
-}
-```
-
-Start the `maco` MCP server:
-
-```bash
-maco serve-mcp --config mcp.json --provider docker
-```
-
-Use `--provider local` for a faster, non-isolated local feedback loop.
-
-By default this serves Streamable HTTP MCP at `http://127.0.0.1:8789/mcp`.
-
-Configure an MCP client to connect to that endpoint:
-
-<details>
-<summary>Codex</summary>
-
-```bash
-codex mcp add maco --url http://127.0.0.1:8789/mcp
-```
-
-</details>
-
-<details>
-<summary>Claude Code</summary>
-
-```bash
-claude mcp add --transport http maco http://127.0.0.1:8789/mcp
-```
-
-</details>
-
-From the client, the agent uses the MCP `bash` tool for code navigation inside the sandbox:
-
-```bash
-rg --files /workspace/macosdk/tools
-sed -n '1,160p' /workspace/macosdk/tools/filesystem/__init__.py
-```
-
-Then use `code_execute` to call tools in a context-efficient manner, using loops and conditions instead of traditional linear tool-call chaining:
-
-```python
-from tools.filesystem import listDirectory
-
-for path in ["/tmp", "/var/tmp"]:
-    listing = listDirectory(path=path)
-    entries = listing if isinstance(listing, list) else getattr(listing, "entries", [])
-
-    if not entries:
-        print(f"{path}: empty")
-    else:
-        print(f"{path}: {len(entries)} entries")
-```
-
-See [`examples/serve-mcp`](examples/serve-mcp) for a complete example that wraps multiple upstream MCP servers behind one `maco` endpoint.
-
-If you are using the source checkout directly, the script wrapper is equivalent:
-
-```bash
-./scripts/maco-serve-mcp --config mcp.json --provider docker
-```
-
-## MCP config
-
-`maco` expects Claude-style JSON with a top-level `mcpServers` object. Supported upstream transports are `stdio`, `http`/`streamable_http`, and `sse`.
-
-Minimal stdio example:
-
-```json
-{
-  "mcpServers": {
-    "filesystem": {
-      "command": "npx",
-      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
-    }
-  }
-}
-```
-
-Minimal Streamable HTTP example:
-
-```json
-{
-  "mcpServers": {
-    "remote": {
-      "type": "http",
-      "url": "http://127.0.0.1:8000/mcp",
-      "headers": {"Authorization": "Bearer ${TOKEN}"}
-    }
-  }
-}
-```
-
-For remote HTTP/SSE servers without a static `Authorization` header, maco can perform OAuth from the upstream server's HTTP `401 Bearer` challenge. See [`docs/mcp-config.md`](docs/mcp-config.md) for the full config reference, including environment expansion, headers, OAuth hints, token caching, and tool filtering.
-
-## Sandbox providers
-
-Choose the execution provider with `--provider`:
-
-- `local` — fastest feedback loop; runs commands as local subprocesses.
-- `docker` — runs commands in a long-lived Docker container.
-- `matchlock` — runs commands in a long-lived Matchlock micro-VM.
-
-The default Docker/Matchlock image is `ghcr.io/jingkaihe/maco:<VERSION>-alpine`, where `<VERSION>` comes from [`VERSION.txt`](VERSION.txt). It includes `maco`, Python 3.12, `uv`, `pydantic`, `rg`, and `fd`.
-
-## Development
-
-```bash
-make check
-make build
-make image
-```
-
-## Safety notes
-
-- `maco serve-mcp` exposes code execution to whatever can reach its HTTP MCP endpoint; bind and firewall it accordingly.
-- The managed gateway uses a bearer token by default. Do not commit `.maco/gateway.json`.
-- Sandbox providers change the isolation boundary, not the authority of the upstream MCP servers. Treat generated tool calls like direct MCP tool calls.
-- Inspect unfamiliar generated wrappers before running code that calls them.
-
-## License
-
-Apache License 2.0. See [`LICENSE`](LICENSE).

mcp_as_code-0.1.2/README.md

@@ -1,189 +0,0 @@
-# maco
-
-`maco` (mcp-as-code) lets an MCP client interact with many upstream MCP tools through a small code-execution interface.
-
-It follows Anthropic's [code-execution-with-MCP pattern](https://www.anthropic.com/engineering/code-execution-with-mcp): keep the large MCP surface area behind a gateway, then let agents write short Python programs for loops, filtering, joins, retries, and structured output. Instead of loading hundreds of tool schemas into the context window, the client gets a compact interface for shell discovery and Python execution.
-
-## At a glance
-
-- Point `maco` at a Claude-style `mcp.json` containing one or many MCP servers.
-- Run `maco serve-mcp` to expose one Streamable HTTP MCP endpoint.
-- Connect your MCP client to that endpoint; it sees only `bash` and `code_execute`.
-- Agents thrive on discovery with `rg` and `fd`, so maco gives them `bash` access to navigate the tool interface as a real filesystem.
-- Use `code_execute` to call upstream MCP tools from Python with `from tools.<server> import <tool>`.
-
-## Why it helps
-
-- **Small context footprint:** the client starts with two tools, not every upstream schema.
-- **Programmatic leverage:** use Python for paging, filtering, joining, caching, retries, and local intermediate files.
-- **Progressive discovery:** inspect only the generated wrappers relevant to the task.
-- **Flexible isolation:** run code locally for fast iteration or inside Docker/Matchlock for stronger isolation.
-- **Works with existing MCP servers:** stdio, Streamable HTTP, and SSE server configs are supported.
-
-## How it works
-
-```text
-MCP client
-    │ sees only bash + code_execute
-    ▼
-maco serve-mcp  ── sandbox ──▶ Python code imports generated tools
-    │
-    ▼
-managed maco gateway
-    │
-    ▼
-upstream MCP servers from mcp.json
-```
-
-`maco serve-mcp` starts a managed gateway for the upstream MCP servers, prepares a generated Python SDK for the sandbox, and serves a compact MCP endpoint for downstream clients.
-
-## Installation
-
-Install the Python package `mcp-as-code`; it provides the `maco` executable:
-
-```bash
-uv tool install mcp-as-code
-```
-
-Then verify the CLI:
-
-```bash
-maco version
-```
-
-## Quick start
-
-Create a Claude-style `mcp.json`:
-
-```json
-{
-  "mcpServers": {
-    "filesystem": {
-      "command": "npx",
-      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
-    }
-  }
-}
-```
-
-Start the `maco` MCP server:
-
-```bash
-maco serve-mcp --config mcp.json --provider docker
-```
-
-Use `--provider local` for a faster, non-isolated local feedback loop.
-
-By default this serves Streamable HTTP MCP at `http://127.0.0.1:8789/mcp`.
-
-Configure an MCP client to connect to that endpoint:
-
-<details>
-<summary>Codex</summary>
-
-```bash
-codex mcp add maco --url http://127.0.0.1:8789/mcp
-```
-
-</details>
-
-<details>
-<summary>Claude Code</summary>
-
-```bash
-claude mcp add --transport http maco http://127.0.0.1:8789/mcp
-```
-
-</details>
-
-From the client, the agent uses the MCP `bash` tool for code navigation inside the sandbox:
-
-```bash
-rg --files /workspace/macosdk/tools
-sed -n '1,160p' /workspace/macosdk/tools/filesystem/__init__.py
-```
-
-Then use `code_execute` to call tools in a context-efficient manner, using loops and conditions instead of traditional linear tool-call chaining:
-
-```python
-from tools.filesystem import listDirectory
-
-for path in ["/tmp", "/var/tmp"]:
-    listing = listDirectory(path=path)
-    entries = listing if isinstance(listing, list) else getattr(listing, "entries", [])
-
-    if not entries:
-        print(f"{path}: empty")
-    else:
-        print(f"{path}: {len(entries)} entries")
-```
-
-See [`examples/serve-mcp`](examples/serve-mcp) for a complete example that wraps multiple upstream MCP servers behind one `maco` endpoint.
-
-If you are using the source checkout directly, the script wrapper is equivalent:
-
-```bash
-./scripts/maco-serve-mcp --config mcp.json --provider docker
-```
-
-## MCP config
-
-`maco` expects Claude-style JSON with a top-level `mcpServers` object. Supported upstream transports are `stdio`, `http`/`streamable_http`, and `sse`.
-
-Minimal stdio example:
-
-```json
-{
-  "mcpServers": {
-    "filesystem": {
-      "command": "npx",
-      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
-    }
-  }
-}
-```
-
-Minimal Streamable HTTP example:
-
-```json
-{
-  "mcpServers": {
-    "remote": {
-      "type": "http",
-      "url": "http://127.0.0.1:8000/mcp",
-      "headers": {"Authorization": "Bearer ${TOKEN}"}
-    }
-  }
-}
-```
-
-For remote HTTP/SSE servers without a static `Authorization` header, maco can perform OAuth from the upstream server's HTTP `401 Bearer` challenge. See [`docs/mcp-config.md`](docs/mcp-config.md) for the full config reference, including environment expansion, headers, OAuth hints, token caching, and tool filtering.
-
-## Sandbox providers
-
-Choose the execution provider with `--provider`:
-
-- `local` — fastest feedback loop; runs commands as local subprocesses.
-- `docker` — runs commands in a long-lived Docker container.
-- `matchlock` — runs commands in a long-lived Matchlock micro-VM.
-
-The default Docker/Matchlock image is `ghcr.io/jingkaihe/maco:<VERSION>-alpine`, where `<VERSION>` comes from [`VERSION.txt`](VERSION.txt). It includes `maco`, Python 3.12, `uv`, `pydantic`, `rg`, and `fd`.
-
-## Development
-
-```bash
-make check
-make build
-make image
-```
-
-## Safety notes
-
-- `maco serve-mcp` exposes code execution to whatever can reach its HTTP MCP endpoint; bind and firewall it accordingly.
-- The managed gateway uses a bearer token by default. Do not commit `.maco/gateway.json`.
-- Sandbox providers change the isolation boundary, not the authority of the upstream MCP servers. Treat generated tool calls like direct MCP tool calls.
-- Inspect unfamiliar generated wrappers before running code that calls them.
-
-## License
-
-Apache License 2.0. See [`LICENSE`](LICENSE).

mcp_as_code-0.1.2/VERSION.txt

@@ -1 +0,0 @@
-0.1.2

mcp_as_code-0.1.2/examples/serve-mcp/README.md

@@ -1,91 +0,0 @@
-# `maco serve-mcp` example
-
-This example shows how to expose several upstream MCP servers through one compact `maco serve-mcp` endpoint. The upstream servers here are:
-
-- [Playwright MCP](https://playwright.dev/mcp/introduction), launched with `npx -y @playwright/mcp@latest`
-- [GitHub MCP server](https://github.com/github/github-mcp-server), launched with the official `ghcr.io/github/github-mcp-server` Docker image
-
-`maco serve-mcp` generates Python wrappers for those upstream tools, starts a managed local gateway that owns the upstream MCP sessions, then starts a Streamable HTTP MCP server with two tools:
-
-- `bash` — inspect generated wrappers or run shell probes in the sandbox
-- `code_execute` — run Python code that imports generated wrappers
-
-```text
-MCP client ──HTTP──▶ maco serve-mcp ──sandbox──▶ generated Python wrappers
-                                      │
-                                      ▼
-                                maco gateway
-                                      │
-                                      ▼
-                         Playwright MCP + GitHub MCP
-```
-
-## Files
-
-- `mcp.json` — upstream MCP servers that `maco serve-mcp` connects to.
-- `mcp-client.json` — example downstream MCP client config that connects to `maco serve-mcp`.
-
-## Prerequisites
-
-- `uv`
-- `node`/`npx`, for Playwright MCP
-- Docker, for GitHub MCP and the Docker sandbox provider
-- Optional: Matchlock, for the Matchlock sandbox provider
-- A GitHub personal access token in `GITHUB_PERSONAL_ACCESS_TOKEN`
-
-If you are already authenticated with the GitHub CLI, export a token directly:
-
-```bash
-export GITHUB_TOKEN=$(gh auth token)
-```
-
-## 1. Start `maco serve-mcp`
-
-The short path is to run from this example directory so the defaults line up with the local files:
-
-```bash
-cd examples/serve-mcp
-uv run maco serve-mcp --provider local
-```
-
-This uses `mcp.json`, writes `.maco/gateway.json`, uses `maco-serve-mcp/` as scratch, starts the gateway, and serves HTTP MCP at `http://127.0.0.1:8789/mcp`. Add `--clean` only when you want to recreate the local generated SDK from scratch.
-
-Inside the MCP client, use the `bash` tool to inspect the generated sandbox SDK progressively:
-
-```bash
-rg --files /workspace/macosdk/tools
-sed -n '1,160p' /workspace/macosdk/tools/playwright/__init__.py
-sed -n '1,160p' /workspace/macosdk/tools/github/__init__.py
-```
-
-To use a different sandbox provider, swap the provider name:
-
-```bash
-uv run maco serve-mcp --provider docker
-uv run maco serve-mcp --provider matchlock
-```
-
-If you prefer to manage the maco gateway separately, run `uv run maco serve` yourself and pass `--gateway-file .maco/gateway.json` to `maco serve-mcp`.
-
-## 2. Connect an MCP client
-
-Configure your MCP client with `examples/serve-mcp/mcp-client.json`:
-
-```json
-{
-  "mcpServers": {
-    "maco": {
-      "type": "http",
-      "url": "http://127.0.0.1:8789/mcp"
-    }
-  }
-}
-```
-
-The client will see only two tools, `bash` and `code_execute`, but those tools can use all generated wrappers for Playwright and GitHub. Code executed in the sandbox imports generated tools with `from tools.<server> import <tool>`.
-
-## Notes
-
-- Prefer calling `code_execute` with only the `code` argument. If `filename` is omitted, maco writes the script to a deterministic `<hash>.py` file in scratch.
-- The Docker and Matchlock providers use the default sandbox image `ghcr.io/jingkaihe/maco:<VERSION>-alpine`, where `<VERSION>` comes from the repository `VERSION.txt`. It includes Python 3.12, `uv`, `pydantic`, `rg`, and `fd`.
-- `.maco/` and `maco-serve-mcp/` are local runtime files and should not be committed.

mcp_as_code-0.1.2/src/maco/_build_info.py

@@ -1,4 +0,0 @@
-"""Build metadata embedded during release builds."""
-
-COMMIT_SHA = "e680ca8b394a20cf951bc0645e452696710ed7de"
-RELEASE_DATE = "2026-06-15"