moonbridge 0.5.2__py3-none-any.whl → 0.7.0__py3-none-any.whl

moonbridge/__init__.py

@@ -1,8 +1,8 @@
-"""MCP server for spawning Kimi K2.5 agents."""
+"""MCP server for spawning AI coding agents."""
 
 from __future__ import annotations
 
-__version__ = "0.5.2"
+__version__ = "0.7.0"
 
 from .server import main, run, server
 

moonbridge/adapters/base.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import Protocol
+from typing import Any, Protocol
 
 
 @dataclass(frozen=True)
@@ -18,6 +18,35 @@ class AdapterConfig:
     default_timeout: int = 600
 
 
+@dataclass(frozen=True)
+class AgentResult:
+    """Agent execution result."""
+
+    status: str
+    output: str
+    stderr: str | None
+    returncode: int
+    duration_ms: int
+    agent_index: int
+    message: str | None = None
+    raw: dict[str, Any] | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "status": self.status,
+            "output": self.output,
+            "stderr": self.stderr,
+            "returncode": self.returncode,
+            "duration_ms": self.duration_ms,
+            "agent_index": self.agent_index,
+        }
+        if self.message is not None:
+            payload["message"] = self.message
+        if self.raw is not None:
+            payload["raw"] = self.raw
+        return payload
+
+
 class CLIAdapter(Protocol):
     """Protocol for CLI backend adapters."""
 

moonbridge/adapters/codex.py

@@ -55,6 +55,7 @@ class CodexAdapter:
             "gpt-5.1-codex-mini",
             "gpt-5.1-codex-max",
         ),
+        default_timeout=1800,  # 30 minutes - Codex runs long
     )
 
     def build_command(

moonbridge/adapters/kimi.py

@@ -38,6 +38,7 @@ class KimiAdapter:
         install_hint="uv tool install kimi-cli",
         supports_thinking=True,
         known_models=("kimi-k2.5",),
+        default_timeout=600,  # 10 minutes - Kimi is faster
     )
 
     def build_command(

moonbridge/sandbox.py

@@ -0,0 +1,252 @@
+"""Copy-on-run sandbox for agent execution."""
+
+from __future__ import annotations
+
+import difflib
+import os
+import shutil
+import tempfile
+import time
+from collections.abc import Callable, Iterator
+from dataclasses import dataclass, replace
+from pathlib import Path
+
+from moonbridge.adapters.base import AgentResult
+
+SANDBOX_IGNORE_DIRS = {
+    ".git",
+    ".venv",
+    ".tox",
+    "__pycache__",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".ruff_cache",
+    "node_modules",
+    "dist",
+    "build",
+}
+SANDBOX_IGNORE_FILES = {".DS_Store"}
+MAX_COPY_BYTES = 500 * 1024 * 1024
+
+
+@dataclass(frozen=True)
+class SandboxResult:
+    diff: str
+    summary: dict[str, int]
+    truncated: bool
+    sandbox_path: str | None
+
+
+def _should_ignore(name: str) -> bool:
+    if name in SANDBOX_IGNORE_DIRS:
+        return True
+    if name in SANDBOX_IGNORE_FILES:
+        return True
+    return name.endswith((".pyc", ".pyo"))
+
+
+def _ignore_names(_dirpath: str, names: list[str]) -> set[str]:
+    return {name for name in names if _should_ignore(name)}
+
+
+def _filtered_walk(root: str) -> Iterator[tuple[str, list[str], list[str]]]:
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames if not _should_ignore(d)]
+        filenames = [f for f in filenames if not _should_ignore(f)]
+        yield dirpath, dirnames, filenames
+
+
+def _collect_files(root: str) -> set[str]:
+    files: set[str] = set()
+    for dirpath, _dirnames, filenames in _filtered_walk(root):
+        rel_dir = os.path.relpath(dirpath, root)
+        for filename in filenames:
+            rel_path = filename if rel_dir == "." else os.path.join(rel_dir, filename)
+            files.add(rel_path)
+    return files
+
+
+def _read_text(path: str) -> str | None:
+    data = Path(path).read_bytes()
+    try:
+        return data.decode("utf-8")
+    except UnicodeDecodeError:
+        return None
+
+
+def _diff_trees(
+    original: str,
+    sandbox: str,
+    max_bytes: int,
+) -> tuple[str, dict[str, int], bool]:
+    original_files = _collect_files(original)
+    sandbox_files = _collect_files(sandbox)
+    all_files = sorted(original_files | sandbox_files)
+    diff_chunks: list[str] = []
+    size = 0
+    truncated = False
+    summary = {"added": 0, "modified": 0, "deleted": 0, "binary": 0}
+
+    def append_chunk(chunk: str) -> None:
+        nonlocal size, truncated
+        if truncated or not chunk:
+            return
+        remaining = max_bytes - size
+        if remaining <= 0:
+            truncated = True
+            return
+        if len(chunk) > remaining:
+            diff_chunks.append(chunk[:remaining])
+            truncated = True
+            size = max_bytes
+            return
+        diff_chunks.append(chunk)
+        size += len(chunk)
+
+    for rel_path in all_files:
+        original_path = os.path.join(original, rel_path)
+        sandbox_path = os.path.join(sandbox, rel_path)
+        original_exists = os.path.exists(original_path)
+        sandbox_exists = os.path.exists(sandbox_path)
+
+        if not original_exists and sandbox_exists:
+            summary["added"] += 1
+            sandbox_text = _read_text(sandbox_path)
+            if sandbox_text is None:
+                summary["binary"] += 1
+                append_chunk(f"Binary files /dev/null and b/{rel_path} differ\n")
+                continue
+            diff = difflib.unified_diff(
+                [],
+                sandbox_text.splitlines(keepends=True),
+                fromfile="/dev/null",
+                tofile=f"b/{rel_path}",
+            )
+            append_chunk("".join(diff))
+            continue
+
+        if original_exists and not sandbox_exists:
+            summary["deleted"] += 1
+            original_text = _read_text(original_path)
+            if original_text is None:
+                summary["binary"] += 1
+                append_chunk(f"Binary files a/{rel_path} and /dev/null differ\n")
+                continue
+            diff = difflib.unified_diff(
+                original_text.splitlines(keepends=True),
+                [],
+                fromfile=f"a/{rel_path}",
+                tofile="/dev/null",
+            )
+            append_chunk("".join(diff))
+            continue
+
+        if not original_exists or not sandbox_exists:
+            continue
+
+        original_bytes = Path(original_path).read_bytes()
+        sandbox_bytes = Path(sandbox_path).read_bytes()
+        if original_bytes == sandbox_bytes:
+            continue
+
+        original_text = None
+        sandbox_text = None
+        try:
+            original_text = original_bytes.decode("utf-8")
+            sandbox_text = sandbox_bytes.decode("utf-8")
+        except UnicodeDecodeError:
+            summary["binary"] += 1
+            append_chunk(f"Binary files a/{rel_path} and b/{rel_path} differ\n")
+            continue
+
+        summary["modified"] += 1
+        diff = difflib.unified_diff(
+            original_text.splitlines(keepends=True),
+            sandbox_text.splitlines(keepends=True),
+            fromfile=f"a/{rel_path}",
+            tofile=f"b/{rel_path}",
+        )
+        append_chunk("".join(diff))
+
+    if truncated:
+        diff_chunks.append("\n... diff truncated ...\n")
+    return ("".join(diff_chunks), summary, truncated)
+
+
+def _estimate_copy_size(root: str, max_bytes: int) -> int:
+    total = 0
+    for dirpath, _dirnames, filenames in _filtered_walk(root):
+        for filename in filenames:
+            path = os.path.join(dirpath, filename)
+            total += os.path.getsize(path)
+            if total > max_bytes:
+                return total
+    return total
+
+
+def _agent_index(fn: Callable[[str], AgentResult]) -> int:
+    value = getattr(fn, "agent_index", 0)
+    return value if isinstance(value, int) else 0
+
+
+def run_sandboxed(
+    fn: Callable[[str], AgentResult],
+    cwd: str,
+    *,
+    max_diff_bytes: int = 500_000,
+    max_copy_bytes: int = MAX_COPY_BYTES,
+    keep: bool = False,
+) -> tuple[AgentResult, SandboxResult | None]:
+    """Run fn in a copy of cwd. Returns (agent_result, sandbox_result).
+
+    On sandbox infrastructure error, returns (error_result, None).
+    """
+    start = time.monotonic()
+    sandbox_root: str | None = None
+    agent_index = _agent_index(fn)
+
+    def error_result(reason: str) -> AgentResult:
+        duration_ms = int((time.monotonic() - start) * 1000)
+        return AgentResult(
+            status="error",
+            output="",
+            stderr=f"sandbox error: {reason}",
+            returncode=-1,
+            duration_ms=duration_ms,
+            agent_index=agent_index,
+        )
+
+    try:
+        total_bytes = _estimate_copy_size(cwd, max_copy_bytes)
+        if total_bytes > max_copy_bytes:
+            return error_result(
+                f"copy size {total_bytes} exceeds max {max_copy_bytes}"
+            ), None
+
+        sandbox_root = tempfile.mkdtemp(prefix="moonbridge-sandbox-")
+        sandbox_cwd = os.path.join(sandbox_root, "workspace")
+        shutil.copytree(cwd, sandbox_cwd, symlinks=False, ignore=_ignore_names)
+
+        result = fn(sandbox_cwd)
+
+        try:
+            diff, summary, truncated = _diff_trees(cwd, sandbox_cwd, max_diff_bytes)
+            sandbox_result = SandboxResult(
+                diff=diff,
+                summary=summary,
+                truncated=truncated,
+                sandbox_path=sandbox_root if keep else None,
+            )
+            return result, sandbox_result
+        except Exception as exc:
+            raw = dict(result.raw or {})
+            sandbox_payload: dict[str, object] = {"enabled": True, "error": str(exc)}
+            if keep:
+                sandbox_payload["path"] = sandbox_root
+            raw["sandbox"] = sandbox_payload
+            return replace(result, raw=raw), None
+    except Exception as exc:
+        return error_result(str(exc)), None
+    finally:
+        if not keep and sandbox_root:
+            shutil.rmtree(sandbox_root, ignore_errors=True)

moonbridge/server.py

@@ -1,4 +1,4 @@
-"""MCP server for spawning Kimi K2.5 agents."""
+"""MCP server for spawning AI coding agents."""
 
 from __future__ import annotations
 
@@ -11,6 +11,7 @@ import signal
 import sys
 import time
 import weakref
+from dataclasses import replace
 from subprocess import PIPE, Popen, TimeoutExpired
 from typing import Any
 
@@ -19,6 +20,8 @@ from mcp.server.stdio import stdio_server
 from mcp.types import TextContent, Tool
 
 from moonbridge.adapters import ADAPTER_REGISTRY, CLIAdapter, get_adapter
+from moonbridge.adapters.base import AgentResult
+from moonbridge.tools import build_tools
 
 server = Server("moonbridge")
 
@@ -34,6 +37,17 @@ ALLOWED_DIRS = [
     if path
 ]
 MAX_PROMPT_LENGTH = 100_000
+_SANDBOX_ENV = os.environ.get("MOONBRIDGE_SANDBOX", "").strip().lower()
+SANDBOX_MODE = _SANDBOX_ENV in {"1", "true", "yes", "copy"}
+SANDBOX_KEEP = os.environ.get("MOONBRIDGE_SANDBOX_KEEP", "").strip().lower() in {
+    "1",
+    "true",
+    "yes",
+}
+SANDBOX_MAX_DIFF_BYTES = int(os.environ.get("MOONBRIDGE_SANDBOX_MAX_DIFF", "500000"))
+SANDBOX_MAX_COPY_BYTES = int(
+    os.environ.get("MOONBRIDGE_SANDBOX_MAX_COPY", str(500 * 1024 * 1024))
+)
 
 _active_processes: set[weakref.ref[Popen[str]]] = set()
 
@@ -71,8 +85,20 @@ def _safe_env(adapter: CLIAdapter) -> dict[str, str]:
     return env
 
 
-def _validate_timeout(timeout_seconds: int | None) -> int:
-    value = DEFAULT_TIMEOUT if timeout_seconds is None else int(timeout_seconds)
+def _resolve_timeout(adapter: CLIAdapter, timeout_seconds: int | None) -> int:
+    """Resolve timeout: explicit > adapter-env > adapter-default > global."""
+    if timeout_seconds is not None:
+        value = int(timeout_seconds)
+    else:
+        # Check adapter-specific env var first
+        env_key = f"MOONBRIDGE_{adapter.config.name.upper()}_TIMEOUT"
+        if env_val := os.environ.get(env_key):
+            value = int(env_val)
+        elif adapter.config.default_timeout != 600:
+            # Use adapter default if explicitly set (not the base default)
+            value = adapter.config.default_timeout
+        else:
+            value = DEFAULT_TIMEOUT
     if value < 30 or value > 3600:
         raise ValueError("timeout_seconds must be between 30 and 3600")
     return value
@@ -180,27 +206,51 @@ def _auth_error(stderr: str | None, adapter: CLIAdapter) -> bool:
     return any(pattern in lowered for pattern in adapter.config.auth_patterns)
 
 
-def _result(
-    *,
-    status: str,
-    output: str,
-    stderr: str | None,
-    returncode: int,
-    duration_ms: int,
+def _run_cli_sandboxed(
+    adapter: CLIAdapter,
+    prompt: str,
+    thinking: bool,
+    cwd: str,
+    timeout_seconds: int,
     agent_index: int,
-    message: str | None = None,
-) -> dict[str, Any]:
-    payload: dict[str, Any] = {
-        "status": status,
-        "output": output,
-        "stderr": stderr,
-        "returncode": returncode,
-        "duration_ms": duration_ms,
-        "agent_index": agent_index,
-    }
-    if message is not None:
-        payload["message"] = message
-    return payload
+    model: str | None = None,
+    reasoning_effort: str | None = None,
+) -> AgentResult:
+    from moonbridge.sandbox import run_sandboxed
+
+    def run_agent(sandbox_cwd: str) -> AgentResult:
+        return _run_cli_sync(
+            adapter,
+            prompt,
+            thinking,
+            sandbox_cwd,
+            timeout_seconds,
+            agent_index,
+            model,
+            reasoning_effort,
+        )
+
+    run_agent.agent_index = agent_index  # type: ignore[attr-defined]
+
+    result, sandbox_result = run_sandboxed(
+        run_agent,
+        cwd,
+        max_diff_bytes=SANDBOX_MAX_DIFF_BYTES,
+        max_copy_bytes=SANDBOX_MAX_COPY_BYTES,
+        keep=SANDBOX_KEEP,
+    )
+    if sandbox_result:
+        raw = dict(result.raw or {})
+        raw["sandbox"] = {
+            "enabled": True,
+            "summary": sandbox_result.summary,
+            "diff": sandbox_result.diff,
+            "truncated": sandbox_result.truncated,
+        }
+        if sandbox_result.sandbox_path:
+            raw["sandbox"]["path"] = sandbox_result.sandbox_path
+        return replace(result, raw=raw)
+    return result
 
 
 def _run_cli_sync(
@@ -212,7 +262,7 @@ def _run_cli_sync(
     agent_index: int,
     model: str | None = None,
     reasoning_effort: str | None = None,
-) -> dict[str, Any]:
+) -> AgentResult:
     start = time.monotonic()
     cmd = adapter.build_command(prompt, thinking, model, reasoning_effort)
     logger.debug("Spawning agent with prompt: %s...", prompt[:100])
@@ -229,7 +279,7 @@ def _run_cli_sync(
     except FileNotFoundError:
         duration_ms = int((time.monotonic() - start) * 1000)
         logger.error("%s CLI not found or not executable", adapter.config.name)
-        return _result(
+        return AgentResult(
             status="error",
             output="",
             stderr=f"{adapter.config.name} CLI not found or not executable",
@@ -240,7 +290,7 @@ def _run_cli_sync(
     except PermissionError as exc:
         duration_ms = int((time.monotonic() - start) * 1000)
         logger.error("Permission denied starting process: %s", exc)
-        return _result(
+        return AgentResult(
             status="error",
             output="",
             stderr=f"Permission denied: {exc}",
@@ -251,7 +301,7 @@ def _run_cli_sync(
     except OSError as exc:
         duration_ms = int((time.monotonic() - start) * 1000)
         logger.error("Failed to start process: %s", exc)
-        return _result(
+        return AgentResult(
             status="error",
             output="",
             stderr=f"Failed to start process: {exc}",
@@ -266,7 +316,7 @@ def _run_cli_sync(
         stderr_value = stderr or None
         if _auth_error(stderr_value, adapter):
             logger.info("Agent %s completed with status: auth_error", agent_index)
-            return _result(
+            return AgentResult(
                 status="auth_error",
                 output=stdout,
                 stderr=stderr_value,
@@ -277,7 +327,7 @@ def _run_cli_sync(
             )
         status = "success" if proc.returncode == 0 else "error"
         logger.info("Agent %s completed with status: %s", agent_index, status)
-        return _result(
+        return AgentResult(
             status=status,
             output=stdout,
             stderr=stderr_value,
@@ -289,7 +339,7 @@ def _run_cli_sync(
         _terminate_process(proc)
         duration_ms = int((time.monotonic() - start) * 1000)
         logger.warning("Agent %s timed out after %s seconds", agent_index, timeout_seconds)
-        return _result(
+        return AgentResult(
             status="timeout",
             output="",
             stderr=None,
@@ -301,7 +351,7 @@ def _run_cli_sync(
         _terminate_process(proc)
         duration_ms = int((time.monotonic() - start) * 1000)
         logger.error("Agent %s failed with error: %s", agent_index, exc)
-        return _result(
+        return AgentResult(
             status="error",
             output="",
             stderr=str(exc),
@@ -313,6 +363,39 @@ def _run_cli_sync(
         _untrack_process(proc)
 
 
+def _run_cli(
+    adapter: CLIAdapter,
+    prompt: str,
+    thinking: bool,
+    cwd: str,
+    timeout_seconds: int,
+    agent_index: int,
+    model: str | None = None,
+    reasoning_effort: str | None = None,
+) -> AgentResult:
+    if SANDBOX_MODE:
+        return _run_cli_sandboxed(
+            adapter,
+            prompt,
+            thinking,
+            cwd,
+            timeout_seconds,
+            agent_index,
+            model,
+            reasoning_effort,
+        )
+    return _run_cli_sync(
+        adapter,
+        prompt,
+        thinking,
+        cwd,
+        timeout_seconds,
+        agent_index,
+        model,
+        reasoning_effort,
+    )
+
+
 def _json_text(payload: Any) -> list[TextContent]:
     return [TextContent(type="text", text=json.dumps(payload, ensure_ascii=True))]
 
@@ -328,14 +411,18 @@ def _status_check(cwd: str, adapter: CLIAdapter) -> dict[str, Any]:
         }
     timeout = min(DEFAULT_TIMEOUT, 60)
     result = _run_cli_sync(adapter, "status check", False, cwd, timeout, 0)
-    if result["status"] == "auth_error":
+    if result.status == "auth_error":
         return {"status": "auth_error", "message": adapter.config.auth_message}
-    if result["status"] == "success":
+    if result.status == "success":
         return {
             "status": "success",
             "message": f"{adapter.config.name} CLI available and authenticated",
         }
-    return {"status": "error", "message": f"{adapter.config.name} CLI error", "details": result}
+    return {
+        "status": "error",
+        "message": f"{adapter.config.name} CLI error",
+        "details": result.to_dict(),
+    }
 
 
 def _adapter_info(cwd: str, adapter: CLIAdapter) -> dict[str, Any]:
@@ -344,7 +431,7 @@ def _adapter_info(cwd: str, adapter: CLIAdapter) -> dict[str, Any]:
     if installed:
         timeout = min(DEFAULT_TIMEOUT, 60)
         result = _run_cli_sync(adapter, "status check", False, cwd, timeout, 0)
-        authenticated = result["status"] == "success"
+        authenticated = result.status == "success"
     return {
         "name": adapter.config.name,
         "description": adapter.config.tool_description,
@@ -359,112 +446,13 @@ def _adapter_info(cwd: str, adapter: CLIAdapter) -> dict[str, Any]:
 async def list_tools() -> list[Tool]:
     adapter = get_adapter()
     tool_desc = adapter.config.tool_description
-    parallel_desc = f"{tool_desc} Run multiple agents in parallel."
     status_desc = f"Verify {adapter.config.name} CLI is installed and authenticated"
-    adapter_schema = {
-        "type": "string",
-        "enum": list(ADAPTER_REGISTRY.keys()),
-        "description": "Backend to use (kimi, codex). Defaults to MOONBRIDGE_ADAPTER env or kimi.",
-    }
-    return [
-        Tool(
-            name="spawn_agent",
-            description=tool_desc,
-            inputSchema={
-                "type": "object",
-                "properties": {
-                    "prompt": {
-                        "type": "string",
-                        "description": "Instructions for the agent (task, context, constraints)",
-                    },
-                    "adapter": adapter_schema,
-                    "thinking": {
-                        "type": "boolean",
-                        "description": "Enable extended reasoning mode for complex tasks",
-                        "default": False,
-                    },
-                    "timeout_seconds": {
-                        "type": "integer",
-                        "description": "Max execution time (30-3600s)",
-                        "default": DEFAULT_TIMEOUT,
-                        "minimum": 30,
-                        "maximum": 3600,
-                    },
-                    "model": {
-                        "type": "string",
-                        "description": (
-                            "Model to use (e.g., 'gpt-5.2-codex', 'kimi-k2.5'). "
-                            "Falls back to MOONBRIDGE_{ADAPTER}_MODEL or MOONBRIDGE_MODEL env vars."
-                        ),
-                    },
-                    "reasoning_effort": {
-                        "type": "string",
-                        "enum": ["low", "medium", "high", "xhigh"],
-                        "description": (
-                            "Reasoning effort for Codex (low, medium, high, xhigh). "
-                            "Ignored for Kimi (use thinking instead)."
-                        ),
-                    },
-                },
-                "required": ["prompt"],
-            },
-        ),
-        Tool(
-            name="spawn_agents_parallel",
-            description=parallel_desc,
-            inputSchema={
-                "type": "object",
-                "properties": {
-                    "agents": {
-                        "type": "array",
-                        "description": "List of agent specs with prompt and optional settings",
-                        "items": {
-                            "type": "object",
-                            "properties": {
-                                "prompt": {"type": "string"},
-                                "adapter": adapter_schema,
-                                "thinking": {"type": "boolean", "default": False},
-                                "timeout_seconds": {
-                                    "type": "integer",
-                                    "description": "Max execution time (30-3600s)",
-                                    "default": DEFAULT_TIMEOUT,
-                                    "minimum": 30,
-                                    "maximum": 3600,
-                                },
-                                "model": {
-                                    "type": "string",
-                                    "description": (
-                                        "Model to use. Falls back to "
-                                        "MOONBRIDGE_{ADAPTER}_MODEL or MOONBRIDGE_MODEL env vars."
-                                    ),
-                                },
-                                "reasoning_effort": {
-                                    "type": "string",
-                                    "enum": ["low", "medium", "high", "xhigh"],
-                                    "description": (
-                                        "Reasoning effort for Codex (low, medium, high, xhigh). "
-                                        "Ignored for Kimi."
-                                    ),
-                                },
-                            },
-                            "required": ["prompt"],
-                        },
-                    },
-                },
-                "required": ["agents"],
-            },
-        ),
-        Tool(
-            name="list_adapters",
-            description="List available adapters and their status",
-            inputSchema={"type": "object", "properties": {}},
-        ),
-        Tool(
-            name="check_status",
-            description=status_desc,
-            inputSchema={"type": "object", "properties": {}},
-        ),
-    ]
+    return build_tools(
+        adapter_names=tuple(ADAPTER_REGISTRY.keys()),
+        default_timeout=DEFAULT_TIMEOUT,
+        tool_description=tool_desc,
+        status_description=status_desc,
+    )
 
 
 async def handle_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
@@ -475,14 +463,14 @@ async def handle_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]
             adapter = get_adapter(arguments.get("adapter"))
             prompt = _validate_prompt(arguments["prompt"])
             thinking = _validate_thinking(adapter, bool(arguments.get("thinking", False)))
-            timeout_seconds = _validate_timeout(arguments.get("timeout_seconds"))
+            timeout_seconds = _resolve_timeout(adapter, arguments.get("timeout_seconds"))
             model = _resolve_model(adapter, arguments.get("model"))
             reasoning_effort = arguments.get("reasoning_effort")
             loop = asyncio.get_running_loop()
             try:
                 result = await loop.run_in_executor(
                     None,
-                    _run_cli_sync,
+                    _run_cli,
                     adapter,
                     prompt,
                     thinking,
@@ -494,16 +482,16 @@ async def handle_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]
                 )
             except asyncio.CancelledError:
                 return _json_text(
-                    _result(
+                    AgentResult(
                         status="cancelled",
                         output="",
                         stderr=None,
                         returncode=-1,
                         duration_ms=0,
                         agent_index=0,
-                    )
+                    ).to_dict()
                 )
-            return _json_text(result)
+            return _json_text(result.to_dict())
 
         if name == "spawn_agents_parallel":
             agents = list(arguments["agents"])
@@ -520,12 +508,12 @@ async def handle_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]
                 tasks.append(
                     loop.run_in_executor(
                         None,
-                        _run_cli_sync,
+                        _run_cli,
                         adapter,
                         prompt,
                         thinking,
                         cwd,
-                        _validate_timeout(spec.get("timeout_seconds")),
+                        _resolve_timeout(adapter, spec.get("timeout_seconds")),
                         idx,
                         model,
                         reasoning_effort,
@@ -535,7 +523,7 @@ async def handle_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]
                 results = await asyncio.gather(*tasks)
             except asyncio.CancelledError:
                 cancelled = [
-                    _result(
+                    AgentResult(
                         status="cancelled",
                         output="",
                         stderr=None,
@@ -545,9 +533,9 @@ async def handle_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]
                     )
                     for idx in range(len(agents))
                 ]
-                return _json_text(cancelled)
-            results.sort(key=lambda item: item["agent_index"])
-            return _json_text(results)
+                return _json_text([item.to_dict() for item in cancelled])
+            results.sort(key=lambda item: item.agent_index)
+            return _json_text([item.to_dict() for item in results])
 
         if name == "list_adapters":
             info = [_adapter_info(cwd, adapter) for adapter in ADAPTER_REGISTRY.values()]

moonbridge/tools.py

@@ -0,0 +1,334 @@
+"""Tool schema definitions for Moonbridge MCP server.
+
+This module provides dataclasses and functions for defining MCP tool schemas
+in a reusable, type-safe manner.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from mcp.types import Tool
+
+
+@dataclass(frozen=True)
+class ParameterDef:
+    """Definition for a JSON Schema parameter."""
+
+    type: str  # "string", "integer", "boolean", "array"
+    description: str
+    default: Any = None
+    enum: tuple[str, ...] | None = None
+    minimum: int | None = None
+    maximum: int | None = None
+    items: dict[str, Any] | None = None  # For array types
+
+
+@dataclass(frozen=True)
+class ToolDef:
+    """Definition for an MCP tool."""
+
+    name: str
+    description_template: str  # May contain {adapter} placeholder
+    parameters: tuple[tuple[str, ParameterDef], ...]  # Ordered (name, param) pairs
+    required: tuple[str, ...] = ()
+
+
+# =============================================================================
+# Reusable parameter definitions
+# =============================================================================
+
+PROMPT_PARAM = ParameterDef(
+    type="string",
+    description="Instructions for the agent (task, context, constraints)",
+)
+
+# Note: ADAPTER_PARAM enum is populated dynamically via build_adapter_param()
+ADAPTER_PARAM_BASE = ParameterDef(
+    type="string",
+    description="Backend to use (kimi, codex). Defaults to MOONBRIDGE_ADAPTER env or kimi.",
+    # enum is set dynamically
+)
+
+THINKING_PARAM = ParameterDef(
+    type="boolean",
+    description="Enable extended reasoning mode for complex tasks",
+    default=False,
+)
+
+# Note: TIMEOUT_PARAM default is populated dynamically
+TIMEOUT_PARAM_BASE = ParameterDef(
+    type="integer",
+    description=(
+        "Max execution time (30-3600s). "
+        "Defaults: Codex=1800s (30min), Kimi=600s (10min). "
+        "Complex implementations may need full 30min+."
+    ),
+    minimum=30,
+    maximum=3600,
+    # default is set dynamically
+)
+
+MODEL_PARAM = ParameterDef(
+    type="string",
+    description=(
+        "Model to use (e.g., 'gpt-5.2-codex', 'kimi-k2.5'). "
+        "Falls back to MOONBRIDGE_{ADAPTER}_MODEL or MOONBRIDGE_MODEL env vars."
+    ),
+)
+
+# Shorter model description for nested items
+MODEL_PARAM_SHORT = ParameterDef(
+    type="string",
+    description=(
+        "Model to use. Falls back to "
+        "MOONBRIDGE_{ADAPTER}_MODEL or MOONBRIDGE_MODEL env vars."
+    ),
+)
+
+REASONING_EFFORT_PARAM = ParameterDef(
+    type="string",
+    description=(
+        "Reasoning effort for Codex (low, medium, high, xhigh). "
+        "Ignored for Kimi (use thinking instead)."
+    ),
+    enum=("low", "medium", "high", "xhigh"),
+)
+
+# Shorter reasoning_effort description for nested items
+REASONING_EFFORT_PARAM_SHORT = ParameterDef(
+    type="string",
+    description=(
+        "Reasoning effort for Codex (low, medium, high, xhigh). "
+        "Ignored for Kimi."
+    ),
+    enum=("low", "medium", "high", "xhigh"),
+)
+
+
+# =============================================================================
+# Helper functions for dynamic parameter creation
+# =============================================================================
+
+
+def _build_adapter_param(adapter_names: tuple[str, ...]) -> ParameterDef:
+    """Create adapter parameter with dynamic enum."""
+    return ParameterDef(
+        type="string",
+        description=ADAPTER_PARAM_BASE.description,
+        enum=adapter_names,
+    )
+
+
+def _build_timeout_param(default_timeout: int) -> ParameterDef:
+    """Create timeout parameter with dynamic default.
+
+    Raises:
+        ValueError: If default_timeout is outside the valid range.
+    """
+    min_timeout = TIMEOUT_PARAM_BASE.minimum
+    max_timeout = TIMEOUT_PARAM_BASE.maximum
+    if min_timeout is not None and default_timeout < min_timeout:
+        raise ValueError(f"default_timeout must be >= {min_timeout}, got {default_timeout}")
+    if max_timeout is not None and default_timeout > max_timeout:
+        raise ValueError(f"default_timeout must be <= {max_timeout}, got {default_timeout}")
+    return ParameterDef(
+        type="integer",
+        description=TIMEOUT_PARAM_BASE.description,
+        default=default_timeout,
+        minimum=min_timeout,
+        maximum=max_timeout,
+    )
+
+
+# =============================================================================
+# Tool definitions
+# =============================================================================
+
+SPAWN_AGENT_TOOL = ToolDef(
+    name="spawn_agent",
+    description_template="{tool_description}",
+    parameters=(
+        ("prompt", PROMPT_PARAM),
+        ("adapter", ADAPTER_PARAM_BASE),  # Will be replaced with dynamic version
+        ("thinking", THINKING_PARAM),
+        ("timeout_seconds", TIMEOUT_PARAM_BASE),  # Will be replaced with dynamic version
+        ("model", MODEL_PARAM),
+        ("reasoning_effort", REASONING_EFFORT_PARAM),
+    ),
+    required=("prompt",),
+)
+
+SPAWN_AGENTS_PARALLEL_TOOL = ToolDef(
+    name="spawn_agents_parallel",
+    description_template="{tool_description} Run multiple agents in parallel.",
+    parameters=(),  # Handled specially due to array items
+    required=("agents",),
+)
+
+LIST_ADAPTERS_TOOL = ToolDef(
+    name="list_adapters",
+    description_template="List available adapters and their status",
+    parameters=(),
+    required=(),
+)
+
+CHECK_STATUS_TOOL = ToolDef(
+    name="check_status",
+    description_template="{status_description}",
+    parameters=(),
+    required=(),
+)
+
+
+# =============================================================================
+# Schema generation functions
+# =============================================================================
+
+
+def _param_to_schema(param: ParameterDef) -> dict[str, Any]:
+    """Convert a ParameterDef to a JSON Schema dict."""
+    schema: dict[str, Any] = {"type": param.type}
+
+    if param.description:
+        schema["description"] = param.description
+    if param.default is not None:
+        schema["default"] = param.default
+    if param.enum is not None:
+        schema["enum"] = list(param.enum)
+    if param.minimum is not None:
+        schema["minimum"] = param.minimum
+    if param.maximum is not None:
+        schema["maximum"] = param.maximum
+    if param.items is not None:
+        schema["items"] = param.items
+
+    return schema
+
+
+def build_input_schema(
+    tool: ToolDef,
+    adapter_names: tuple[str, ...],
+    default_timeout: int,
+) -> dict[str, Any]:
+    """Convert ToolDef to MCP inputSchema dict.
+
+    Args:
+        tool: The tool definition to convert.
+        adapter_names: Tuple of available adapter names for enum.
+        default_timeout: Default timeout value for timeout parameters.
+
+    Returns:
+        A JSON Schema dict suitable for MCP Tool.inputSchema.
+    """
+    properties: dict[str, Any] = {}
+
+    for name, param in tool.parameters:
+        # Handle dynamic parameters
+        if name == "adapter":
+            param = _build_adapter_param(adapter_names)
+        elif name == "timeout_seconds":
+            param = _build_timeout_param(default_timeout)
+
+        properties[name] = _param_to_schema(param)
+
+    schema: dict[str, Any] = {
+        "type": "object",
+        "properties": properties,
+    }
+
+    if tool.required:
+        schema["required"] = list(tool.required)
+
+    return schema
+
+
+def _build_agents_array_schema(
+    adapter_names: tuple[str, ...],
+    default_timeout: int,
+) -> dict[str, Any]:
+    """Build the schema for the agents array in spawn_agents_parallel."""
+    adapter_schema = _param_to_schema(_build_adapter_param(adapter_names))
+    timeout_schema = _param_to_schema(_build_timeout_param(default_timeout))
+
+    return {
+        "type": "array",
+        "description": "List of agent specs with prompt and optional settings",
+        "items": {
+            "type": "object",
+            "properties": {
+                "prompt": {"type": "string"},
+                "adapter": adapter_schema,
+                "thinking": {"type": "boolean", "default": False},
+                "timeout_seconds": timeout_schema,
+                "model": _param_to_schema(MODEL_PARAM_SHORT),
+                "reasoning_effort": _param_to_schema(REASONING_EFFORT_PARAM_SHORT),
+            },
+            "required": ["prompt"],
+        },
+    }
+
+
+def build_tools(
+    adapter_names: tuple[str, ...],
+    default_timeout: int,
+    tool_description: str,
+    status_description: str,
+) -> list[Tool]:
+    """Build all MCP Tool objects from definitions.
+
+    Args:
+        adapter_names: Tuple of available adapter names.
+        default_timeout: Default timeout value in seconds.
+        tool_description: Description for the spawn_agent tool.
+        status_description: Description for the check_status tool.
+
+    Returns:
+        List of MCP Tool objects ready for registration.
+    """
+    # spawn_agent
+    spawn_agent_schema = build_input_schema(
+        SPAWN_AGENT_TOOL, adapter_names, default_timeout
+    )
+
+    # spawn_agents_parallel (special handling for array)
+    parallel_schema: dict[str, Any] = {
+        "type": "object",
+        "properties": {
+            "agents": _build_agents_array_schema(adapter_names, default_timeout),
+        },
+        "required": ["agents"],
+    }
+
+    # list_adapters
+    list_adapters_schema: dict[str, Any] = {"type": "object", "properties": {}}
+
+    # check_status
+    check_status_schema: dict[str, Any] = {"type": "object", "properties": {}}
+
+    return [
+        Tool(
+            name="spawn_agent",
+            description=tool_description,
+            inputSchema=spawn_agent_schema,
+        ),
+        Tool(
+            name="spawn_agents_parallel",
+            description=f"{tool_description} Run multiple agents in parallel.",
+            inputSchema=parallel_schema,
+        ),
+        Tool(
+            name="list_adapters",
+            description="List available adapters and their status",
+            inputSchema=list_adapters_schema,
+        ),
+        Tool(
+            name="check_status",
+            description=status_description,
+            inputSchema=check_status_schema,
+        ),
+    ]
+
+
+__all__ = ["build_tools"]

{moonbridge-0.5.2.dist-info → moonbridge-0.7.0.dist-info}/METADATA

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: moonbridge
-Version: 0.5.2
-Summary: MCP server for spawning Kimi K2.5 agents
+Version: 0.7.0
+Summary: MCP server for spawning AI coding agents (Kimi, Codex, and more)
 Project-URL: Homepage, https://github.com/misty-step/moonbridge
 Project-URL: Repository, https://github.com/misty-step/moonbridge
 Project-URL: Issues, https://github.com/misty-step/moonbridge/issues
 Author-email: Phaedrus <hello@mistystep.io>
 License-Expression: MIT
 License-File: LICENSE
-Keywords: agent,ai,claude,kimi,mcp
+Keywords: agent,ai,claude,codex,kimi,mcp
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -31,7 +31,7 @@ Description-Content-Type: text/markdown
 
 **Your MCP client just got a team.**
 
-Spawn Kimi K2.5 agents from Claude Code, Cursor, or any MCP client. Run 10 approaches in parallel for the cost of one Claude request.
+Spawn AI coding agents from Claude Code, Cursor, or any MCP client. Run 10 approaches in parallel for a fraction of the cost.
 
 ```bash
 uvx moonbridge
@@ -39,10 +39,12 @@ uvx moonbridge
 
 ## Quick Start
 
-1. **Install Kimi CLI and authenticate:**
-   ```bash
-   uv tool install --python 3.13 kimi-cli && kimi login
-   ```
+1. **Install at least one supported CLI:**
+
+   | Adapter | Install | Authenticate |
+   |---------|---------|--------------|
+   | Kimi (default) | `uv tool install --python 3.13 kimi-cli` | `kimi login` |
+   | Codex | `npm install -g @openai/codex` | Set `OPENAI_API_KEY` |
 
 2. **Add to MCP config** (`~/.mcp.json`):
    ```json
@@ -94,7 +96,8 @@ export MOONBRIDGE_SKIP_UPDATE_CHECK=1
 |------|----------|
 | `spawn_agent` | Single task: "Write tests for auth.ts" |
 | `spawn_agents_parallel` | Go wide: 10 agents, 10 approaches, pick the best |
-| `check_status` | Verify Kimi CLI is installed and authenticated |
+| `check_status` | Verify the configured CLI is installed and authenticated |
+| `list_adapters` | Show available adapters and their status |
 
 ### Example: Parallel Exploration
 
@@ -117,7 +120,10 @@ Three approaches. One request. You choose the winner.
 | Parameter | Type | Required | Description |
 |-----------|------|----------|-------------|
 | `prompt` | string | Yes | Task description for the agent |
-| `thinking` | boolean | No | Enable reasoning mode (default: false) |
+| `adapter` | string | No | Backend to use: `kimi`, `codex` (default: `kimi`) |
+| `model` | string | No | Model override (e.g., `gpt-5.2-codex`) |
+| `thinking` | boolean | No | Enable reasoning mode (Kimi only) |
+| `reasoning_effort` | string | No | Reasoning budget: `low`, `medium`, `high`, `xhigh` (Codex only) |
 | `timeout_seconds` | integer | No | Override default timeout (30-3600) |
 
 **`spawn_agents_parallel`**
@@ -126,7 +132,10 @@ Three approaches. One request. You choose the winner.
 |-----------|------|----------|-------------|
 | `agents` | array | Yes | List of agent configs (max 10) |
 | `agents[].prompt` | string | Yes | Task for this agent |
-| `agents[].thinking` | boolean | No | Enable reasoning for this agent |
+| `agents[].adapter` | string | No | Backend for this agent |
+| `agents[].model` | string | No | Model override for this agent |
+| `agents[].thinking` | boolean | No | Enable reasoning (Kimi only) |
+| `agents[].reasoning_effort` | string | No | Reasoning budget (Codex only) |
 | `agents[].timeout_seconds` | integer | No | Timeout for this agent |
 
 ## Response Format
@@ -136,12 +145,13 @@ All tools return JSON with these fields:
 | Field | Type | Description |
 |-------|------|-------------|
 | `status` | string | `success`, `error`, `timeout`, `auth_error`, or `cancelled` |
-| `output` | string | stdout from Kimi agent |
+| `output` | string | stdout from the agent |
 | `stderr` | string\|null | stderr if any |
 | `returncode` | int | Process exit code (-1 for timeout/error) |
 | `duration_ms` | int | Execution time in milliseconds |
 | `agent_index` | int | Agent index (0 for single, 0-N for parallel) |
 | `message` | string? | Human-readable error context (when applicable) |
+| `raw` | object? | Optional structured metadata (e.g., sandbox diff) |
 
 ## Configuration
 
@@ -154,41 +164,68 @@ All tools return JSON with these fields:
 | `MOONBRIDGE_MAX_AGENTS` | Maximum parallel agents |
 | `MOONBRIDGE_ALLOWED_DIRS` | Colon-separated allowlist of working directories |
 | `MOONBRIDGE_STRICT` | Set to `1` to require `ALLOWED_DIRS` (exits if unset) |
+| `MOONBRIDGE_SANDBOX` | Set to `1` to run agents in a temp copy of cwd |
+| `MOONBRIDGE_SANDBOX_KEEP` | Set to `1` to keep sandbox dir for inspection |
+| `MOONBRIDGE_SANDBOX_MAX_DIFF` | Max diff size in bytes (default 500000) |
+| `MOONBRIDGE_SANDBOX_MAX_COPY` | Max sandbox copy size in bytes (default 500MB) |
 | `MOONBRIDGE_LOG_LEVEL` | Set to `DEBUG` for verbose logging |
 
 ## Troubleshooting
 
-### "Kimi CLI not found"
+### "CLI not found"
 
-Install the Kimi CLI:
+Install the CLI for your chosen adapter:
 
 ```bash
+# Kimi
 uv tool install --python 3.13 kimi-cli
 which kimi
+
+# Codex
+npm install -g @openai/codex
+which codex
 ```
 
 ### "auth_error" responses
 
-Authenticate with Kimi:
+Authenticate with your chosen CLI:
 
 ```bash
+# Kimi
 kimi login
+
+# Codex
+export OPENAI_API_KEY=sk-...
 ```
 
 ### Timeout errors
 
-Increase the timeout for long-running tasks:
+Adapters have sensible defaults: Codex=1800s (30min), Kimi=600s (10min).
+
+For exceptionally long tasks, override explicitly:
 
 ```json
-{"prompt": "...", "timeout_seconds": 1800}
+{"prompt": "...", "timeout_seconds": 3600}
 ```
 
-Or set a global default:
+Or set per-adapter defaults via environment:
 
 ```bash
-export MOONBRIDGE_TIMEOUT=1800
+export MOONBRIDGE_CODEX_TIMEOUT=2400  # 40 minutes
+export MOONBRIDGE_KIMI_TIMEOUT=900    # 15 minutes
 ```
 
+## Timeout Best Practices
+
+| Task Type | Recommended |
+|-----------|-------------|
+| Quick query, status | 60-180s |
+| Simple edits | 300-600s |
+| Feature implementation | 1200-1800s |
+| Large refactor | 1800-3600s |
+
+Priority resolution: explicit param > adapter env > adapter default > global env > 600s fallback
+
 ### "MOONBRIDGE_ALLOWED_DIRS is not set" warning
 
 By default, Moonbridge warns at startup if no directory restrictions are configured. This is expected for local development. For shared/production environments, set allowed directories:
@@ -197,6 +234,29 @@ By default, Moonbridge warns at startup if no directory restrictions are configu
 export MOONBRIDGE_ALLOWED_DIRS="/path/to/project:/another/path"
 ```
 
+## Sandbox Mode (Copy-on-Run)
+
+Enable sandbox mode to run agents in a temporary copy of the working directory:
+
+```bash
+export MOONBRIDGE_SANDBOX=1
+```
+
+When enabled:
+- Agents run in a temp copy of `cwd`.
+- Host files stay unchanged by default.
+- A unified diff + summary is included in `raw.sandbox`.
+
+Optional:
+
+```bash
+export MOONBRIDGE_SANDBOX_KEEP=1       # keep temp dir
+export MOONBRIDGE_SANDBOX_MAX_DIFF=200000
+export MOONBRIDGE_SANDBOX_MAX_COPY=300000000
+```
+
+Limitations: this is not OS-level isolation. Agents can still read/write arbitrary host paths if they choose to. Use containers/VMs for strong isolation.
+
 To enforce restrictions (exit instead of warn):
 
 ```bash

moonbridge-0.7.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+moonbridge/__init__.py,sha256=vAOZaP2bQ71gulCrthXRbsd5zOWB5R3cdUHNrLuS87w,198
+moonbridge/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+moonbridge/sandbox.py,sha256=4-eIu-rURtaxKKg-d3iWwNq_x6MB_uiJBBG2uMwoKcM,7907
+moonbridge/server.py,sha256=FqnoAd-WAWOX-elNgyOQ-vAiFqsGOdsyQCIsnu1e1t0,19469
+moonbridge/tools.py,sha256=uw338Dilrto2t5dL9XbK4O31-JdB7Vh9RqCXHg20gHI,10126
+moonbridge/version_check.py,sha256=VQueK0O_b-2Xc-XjupJsoW3Zs1Kce5q_BgqBhANGXN8,4579
+moonbridge/adapters/__init__.py,sha256=w3pLvjtC2XnUhf9UzNmniQB3oq4rG8gorSH0tWR-BEE,988
+moonbridge/adapters/base.py,sha256=REoEsAcqEvyVQpTgz6ytd9ioxag--nnvX90YBXMQG8Y,1716
+moonbridge/adapters/codex.py,sha256=GtU4CrJ4zt0WDcKKaOeN7gH4JFIBAo3L7KAZ99zRjiY,2935
+moonbridge/adapters/kimi.py,sha256=ejCxG2OGr0Qr4n0psL6p96_mMJ3lLKMbGcNYWkuC0uA,2189
+moonbridge-0.7.0.dist-info/METADATA,sha256=cWa3osY8GxLAkoJPkkwT4sOKYWkcW80eMjdPcv2FPKw,8305
+moonbridge-0.7.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+moonbridge-0.7.0.dist-info/entry_points.txt,sha256=kgL38HQy3adncDQl_o5sdtPRog56zKdHk6pKKzyR6Ww,54
+moonbridge-0.7.0.dist-info/licenses/LICENSE,sha256=7WMSJoybL2cUot_wb9GUrw5mzfFmtrDzqlMS9ZE709g,1065
+moonbridge-0.7.0.dist-info/RECORD,,

moonbridge-0.5.2.dist-info/RECORD

@@ -1,13 +0,0 @@
-moonbridge/__init__.py,sha256=x3eYCVqjhWKoPmGJvOV3IALPoS1DFO-iZRECuVbNgtQ,198
-moonbridge/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-moonbridge/server.py,sha256=rP3c0hcuUDxC5QqPNWboJZYnMS4hZw6oqkzmg-N0WwM,21194
-moonbridge/version_check.py,sha256=VQueK0O_b-2Xc-XjupJsoW3Zs1Kce5q_BgqBhANGXN8,4579
-moonbridge/adapters/__init__.py,sha256=w3pLvjtC2XnUhf9UzNmniQB3oq4rG8gorSH0tWR-BEE,988
-moonbridge/adapters/base.py,sha256=bj_Ms55h2lwDmEO0CZ1RFSAA9IHgNbX2LI1xgQEftLY,942
-moonbridge/adapters/codex.py,sha256=JTt9B3eXqset6ZrwwlnHzcno5PMdrjY2GdLSNPYkowQ,2873
-moonbridge/adapters/kimi.py,sha256=75QFPTMVpgbgkVGv8GEpIYY1zrIOZ0kJ-aCgd8Tx0TA,2129
-moonbridge-0.5.2.dist-info/METADATA,sha256=aaN1N00Q5oY2bE6faQWW163_goAPVMQDtEEWTlkUnBE,5984
-moonbridge-0.5.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-moonbridge-0.5.2.dist-info/entry_points.txt,sha256=kgL38HQy3adncDQl_o5sdtPRog56zKdHk6pKKzyR6Ww,54
-moonbridge-0.5.2.dist-info/licenses/LICENSE,sha256=7WMSJoybL2cUot_wb9GUrw5mzfFmtrDzqlMS9ZE709g,1065
-moonbridge-0.5.2.dist-info/RECORD,,