contree-mcp 0.1.0__py3-none-any.whl

contree_mcp/tools/upload.py

@@ -0,0 +1,50 @@
+import base64
+import os
+
+from contree_mcp.backend_types import FileResponse
+from contree_mcp.context import CLIENT
+
+
+async def upload(
+    path: str | None = None, content: str | None = None, content_base64: str | None = None
+) -> FileResponse:
+    """
+    Upload file to Contree for use in containers. Free (no VM).
+
+    TL;DR:
+    - PURPOSE: Upload single file, get UUID for run's tool files param
+    - PREFER RSYNC: For multiple files or directories (has caching)
+    - BINARY: Use content_base64 for binary files
+
+    USAGE:
+    - Upload single file for injection into containers
+    - Pass returned UUID to run's tool via files parameter
+    - Use rsync instead for multiple files or directories
+
+    RETURNS: uuid, sha256
+
+    GUIDES:
+    - [USEFUL] contree://guide/quickstart - File sync + execute patterns
+    """
+
+    if not path and not content and not content_base64:
+        raise ValueError("One of 'path', 'content', or 'content_base64' is required")
+
+    if path:
+        path = os.path.expanduser(path)
+        if not os.path.exists(path):
+            raise ValueError(f"File not found: {path}")
+
+    client = CLIENT.get()
+
+    if path:
+        with open(path, "rb") as f:
+            result = await client.upload_file(f)
+        return FileResponse(uuid=result.uuid, sha256=result.sha256)
+    elif content_base64:
+        data = base64.b64decode(content_base64)
+    else:
+        data = content.encode("utf-8")  # type: ignore[union-attr]
+
+    result = await client.upload_file(data)
+    return FileResponse(uuid=result.uuid, sha256=result.sha256)

contree_mcp/tools/wait_operations.py

@@ -0,0 +1,79 @@
+import asyncio
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from contree_mcp.backend_types import OperationKind, OperationResponse, OperationStatus
+from contree_mcp.context import CLIENT
+
+
+class WaitOperationsOutput(BaseModel):
+    results: dict[str, OperationResponse] = Field(description="Map of operation_id to result")
+    completed: list[str] = Field(description="List of completed operation IDs")
+    cancelled: list[str] = Field(description="List of timed out and cancelled operation IDs")
+    timed_out: bool = Field(default=False, description="True if wait exceeded timeout")
+
+
+async def wait_operations(
+    operation_ids: list[str],
+    timeout: float = 300.0,
+    mode: Literal["all", "any"] = "all",
+) -> WaitOperationsOutput:
+    """
+    Wait for multiple operations to complete. Free (no VM).
+
+    TL;DR:
+    - PURPOSE: Block until async operations finish
+    - MODES: 'all' waits for all, 'any' returns on first completion but cancels others
+    - COST: Free (no VM)
+
+    USAGE:
+    - Wait for parallel commands launched with wait=false
+    - Use mode='any' for race conditions (first result wins, others cancelled)
+    - Use mode='all' (default) to collect all results
+
+    RETURNS: results dict, completed list, pending list, timed_out bool
+
+    GUIDES:
+    - [ESSENTIAL] contree://guide/async - Parallel execution patterns
+    """
+
+    client = CLIENT.get()
+
+    results: dict[str, OperationResponse] = {}
+
+    async def wait_one(op_id: str) -> None:
+        nonlocal results
+        try:
+            result = await client.wait_for_operation(op_id, max_wait=timeout)
+            results[op_id] = result
+        except Exception as e:
+            # On error (timeout, connection error, etc.), mark as failed
+            results[op_id] = OperationResponse(
+                uuid=op_id,
+                status=OperationStatus.FAILED,
+                kind=OperationKind.INSTANCE,
+                error=str(e),
+            )
+
+    done, pending = await asyncio.wait(
+        list(map(asyncio.create_task, map(wait_one, set(operation_ids)))),
+        return_when=asyncio.ALL_COMPLETED if mode == "all" else asyncio.FIRST_COMPLETED,
+    )
+
+    for task in pending:
+        if not task.done():
+            task.cancel()
+
+    await asyncio.gather(*pending, return_exceptions=True)
+
+    cancelled_ids = [op_id for op_id in operation_ids if op_id not in results]
+    # timed_out is True only if we have pending tasks AND mode was "all"
+    # For mode="any", having pending tasks is expected behavior
+    timed_out = len(pending) > 0 and mode == "all"
+    return WaitOperationsOutput(
+        results=results,
+        completed=list(results.keys()),
+        cancelled=cancelled_ids,
+        timed_out=timed_out,
+    )

contree_mcp-0.1.0.dist-info/METADATA

@@ -0,0 +1,450 @@
+Metadata-Version: 2.4
+Name: contree-mcp
+Version: 0.1.0
+Summary: MCP server for Contree container management system
+License-Expression: Apache-2.0
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: aiosqlite>=0.19.0
+Requires-Dist: argclass>=1.0.0
+Requires-Dist: httpx>=0.28.0
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: furo>=2024.0.0; extra == 'dev'
+Requires-Dist: mypy>=1.8.0; extra == 'dev'
+Requires-Dist: myst-parser>=3.0.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.2.0; extra == 'dev'
+Requires-Dist: sphinx-copybutton>=0.5.0; extra == 'dev'
+Requires-Dist: sphinx-design>=0.5.0; extra == 'dev'
+Requires-Dist: sphinx>=7.0.0; extra == 'dev'
+Requires-Dist: sphinxcontrib-mermaid>=0.9.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Contree MCP Server
+
+[![PyPI](https://img.shields.io/pypi/v/contree-mcp.svg)](https://pypi.org/project/contree-mcp/)
+[![Tests](https://github.com/nebius/contree-mcp/actions/workflows/tests.yml/badge.svg)](https://github.com/nebius/contree-mcp/actions/workflows/tests.yml)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
+
+Run code in isolated cloud containers. Contree gives AI agents secure sandboxed execution environments with full root access, network, and persistent images.
+
+## Why Contree?
+
+**Fearless experimentation.** Agents can:
+- Run destructive commands (`rm -rf /`, `dd`, kernel exploits) - nothing escapes the sandbox
+- Make mistakes freely - revert to any previous image UUID at zero cost
+- Execute potentially dangerous user requests - Contree IS the safe runtime for risky operations
+- Break things on purpose - corrupt filesystems, crash kernels, test failure modes
+
+Every container is isolated. Every image is immutable. Branching is cheap. Mistakes are free.
+
+## Quick Setup
+
+### 1. Create Config File
+
+Store credentials in `~/.config/contree/mcp.ini`:
+
+```ini
+[DEFAULT]
+url = https://contree.dev/
+token = <TOKEN HERE>
+```
+
+### 2. Configure Your MCP Client
+
+#### Claude Code
+
+Add to `~/.claude/settings.json`:
+
+```json
+{"mcpServers": {"contree": {"command": "uvx", "args": ["contree-mcp"]}}}
+```
+
+Restart Claude Code or run `/mcp` to verify.
+
+#### OpenAI Codex CLI
+
+Add to `~/.codex/config.toml`:
+
+```toml
+[mcp_servers.contree]
+command = "uvx"
+args = ["contree-mcp"]
+```
+
+#### Claude Desktop
+
+Add to config file:
+- macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- Windows: `%APPDATA%\Claude\claude_desktop_config.json`
+
+```json
+{"mcpServers": {"contree": {"command": "uvx", "args": ["contree-mcp"]}}}
+```
+
+> **Note:** You can alternatively pass credentials via environment variables (`CONTREE_MCP_TOKEN`, `CONTREE_MCP_URL`) in your MCP client config, but this is not recommended as tokens may appear in process listings.
+
+## Manual Installation
+
+```bash
+# Using uv
+uv pip install contree-mcp
+
+# Using pip
+pip install contree-mcp
+
+# Run manually
+contree-mcp --token YOUR_TOKEN
+
+# HTTP mode (for network access)
+contree-mcp --mode http --http-port 9452 --token YOUR_TOKEN
+
+# Visit http://localhost:9452/ for interactive documentation with
+# setup guides, tool reference, and best practices.
+```
+
+### Container Installation (Alpine/Ubuntu/Debian)
+
+PEP 668 requires additional flags:
+
+```bash
+pip install --break-system-packages contree-mcp
+uv pip install --break-system-packages --python /usr/bin/python3 contree-mcp
+```
+
+## Configuration
+
+| Argument | Environment Variable | Default |
+|----------|---------------------|---------|
+| - | `CONTREE_MCP_CONFIG` | `~/.config/contree/mcp.ini` |
+| `--token` | `CONTREE_MCP_TOKEN` | (required) |
+| `--url` | `CONTREE_MCP_URL` | `https://contree.dev/` |
+| `--mode` | `CONTREE_MCP_MODE` | `stdio` |
+| `--http-port` | `CONTREE_MCP_HTTP_PORT` | `9452` |
+| `--log-level` | `CONTREE_MCP_LOG_LEVEL` | `warning` |
+
+## Available Tools
+
+### Command Execution
+
+| Tool | Description |
+|------|-------------|
+| `contree_run` | Execute command in container (spawns microVM). Supports `wait=false` for async execution. |
+
+### Image Management
+
+| Tool | Description |
+|------|-------------|
+| `contree_list_images` | List available container images |
+| `contree_get_image` | Get image details by UUID or tag |
+| `contree_import_image` | Import OCI image from registry (requires authentication) |
+| `contree_registry_token_obtain` | Open browser to create PAT for registry authentication |
+| `contree_registry_auth` | Validate and store registry credentials |
+| `contree_set_tag` | Set or remove a tag for an image |
+
+### File Transfer
+
+| Tool | Description |
+|------|-------------|
+| `contree_upload` | Upload a file to Contree for use in containers |
+| `contree_download` | Download a file from a container image to local filesystem |
+| `contree_rsync` | Sync local files to Contree with caching and deduplication |
+
+### Image Inspection
+
+| Tool | Description |
+|------|-------------|
+| `contree_list_files` | List files and directories in an image (no VM needed) |
+| `contree_read_file` | Read a file from an image (no VM needed) |
+
+### Operations
+
+| Tool | Description |
+|------|-------------|
+| `contree_list_operations` | List operations (running or completed) |
+| `contree_get_operation` | Get operation status and result |
+| `contree_wait_operations` | Wait for multiple async operations to complete |
+| `contree_cancel_operation` | Cancel a running operation |
+
+### Documentation
+
+| Tool | Description |
+|------|-------------|
+| `contree_get_guide` | Get agent guide sections (workflow, quickstart, async, etc.) |
+
+## Resource Templates
+
+MCP resource templates expose image files and documentation directly via URIs. Fast operations, no VM required.
+
+| Resource | URI Template | Description |
+|----------|--------------|-------------|
+| `contree_image_read` | `contree://image/{image}/read/{path}` | Read a file from an image |
+| `contree_image_ls` | `contree://image/{image}/ls/{path}` | List directory in an image |
+| `contree_image_lineage` | `contree://image/{image}/lineage` | View image parent-child relationships |
+| `contree_guide` | `contree://guide/{section}` | Agent guide and best practices |
+
+**URI Examples:**
+- `contree://image/abc-123-uuid/read/etc/passwd` - Read file by image UUID
+- `contree://image/tag:alpine:latest/read/etc/os-release` - Read file by tag
+- `contree://image/abc-123-uuid/ls/.` - List root directory
+- `contree://image/tag:python:3.11/ls/usr/local/lib` - List nested directory
+- `contree://image/abc-123-uuid/lineage` - View image ancestry and children
+- `contree://guide/reference` - Tool reference
+- `contree://guide/quickstart` - Common workflow patterns
+
+**Guide Sections:** `workflow`, `reference`, `quickstart`, `state`, `async`, `tagging`, `errors`
+
+## Examples
+
+### Prepare a Reusable Environment (Recommended First Step)
+
+**Step 1: Check for existing environment**
+```json
+// contree_list_images
+{"tag_prefix": "common/python-ml"}
+```
+
+**Step 2: If not found, build and tag it**
+```json
+// contree_import_image
+{"registry_url": "docker://docker.io/python:3.11-slim"}
+
+// contree_run (install packages)
+{"command": "pip install numpy pandas scikit-learn", "image": "<result_image>", "disposable": false}
+
+// contree_set_tag
+{"image_uuid": "<result_image>", "tag": "common/python-ml/python:3.11-slim"}
+```
+
+**Step 3: Use the prepared environment**
+```json
+// contree_run
+{"command": "python train_model.py", "image": "tag:common/python-ml/python:3.11-slim"}
+```
+
+### Run a command
+
+**contree_run:**
+```json
+{"command": "python -c 'print(\"Hello from Contree!\")'", "image": "tag:python:3.11"}
+```
+
+### Parallel Execution (Async Pattern)
+
+Launch multiple instances simultaneously with `wait: false`, then poll for results:
+
+**contree_run** (x3):
+```json
+{"command": "python experiment_a.py", "image": "tag:python:3.11", "wait": false}
+{"command": "python experiment_b.py", "image": "tag:python:3.11", "wait": false}
+{"command": "python experiment_c.py", "image": "tag:python:3.11", "wait": false}
+```
+
+Each returns immediately with `operation_id`. Poll with **contree_get_operation**:
+```json
+{"operation_id": "op-1"}
+```
+
+### Trie-like Exploration Tree
+
+Build branching structures where results become new source images.
+
+**contree_run** - create branch point with `disposable: false`:
+```json
+{"command": "pip install numpy pandas", "image": "tag:python:3.11", "disposable": false}
+```
+Returns `result_image: "img-with-deps"`.
+
+**contree_run** - branch into parallel experiments:
+```json
+{"command": "python test_numpy.py", "image": "img-with-deps", "wait": false}
+{"command": "python test_pandas.py", "image": "img-with-deps", "wait": false}
+```
+
+### Sync Local Files to Container
+
+**contree_rsync** - sync a project directory:
+```json
+{
+  "source": "/path/to/project",
+  "destination": "/app",
+  "exclude": ["__pycache__", "*.pyc", ".git", "node_modules"]
+}
+```
+Returns `directory_state_id: "ds_abc123"`.
+
+**contree_run** - run with injected files:
+```json
+{
+  "command": "python /app/main.py",
+  "image": "tag:python:3.11",
+  "directory_state_id": "ds_abc123"
+}
+```
+
+### List images
+
+**contree_list_images:**
+```json
+{"tag_prefix": "python"}
+```
+
+### Read a file (Resource Template)
+
+Use the `contree_image_file` resource template:
+```
+contree://image/tag:busybox:latest/read/etc/passwd
+```
+
+### Import an image
+
+**Step 1: Authenticate with registry (first time only)**
+
+```json
+// contree_registry_token_obtain - opens browser for PAT creation
+{"registry_url": "docker://docker.io/alpine:latest"}
+
+// contree_registry_auth - validate and store credentials
+{"registry_url": "docker://docker.io/alpine:latest", "username": "myuser", "token": "dckr_pat_xxx"}
+```
+
+**Step 2: Import the image**
+
+```json
+// contree_import_image
+{"registry_url": "docker://docker.io/alpine:latest"}
+```
+
+To make it reusable, tag after importing:
+```json
+// contree_set_tag
+{"image_uuid": "<result_image>", "tag": "common/base/alpine:latest"}
+```
+
+### Track Image Lineage
+
+View parent-child relationships and navigate image history using the `contree_image_lineage` resource:
+
+```
+contree://image/abc-123-uuid/lineage
+```
+
+Returns:
+```json
+{
+  "image": "abc-123-uuid",
+  "parent": {"image": "parent-uuid", "command": "pip install numpy", "exit_code": 0},
+  "children": [{"image": "child-uuid", "command": "python test.py", ...}],
+  "ancestors": [/* parent chain up to root */],
+  "root": {"image": "root-uuid", "registry_url": "docker://python:3.11", "is_import": true},
+  "depth": 2,
+  "is_known": true
+}
+```
+
+Use this to rollback to any ancestor or understand how an image was created.
+
+### Download a build artifact
+
+**contree_download:**
+```json
+{"image": "img-build-result", "path": "/app/dist/binary", "destination": "./binary", "executable": true}
+```
+
+## Dependencies
+
+- `mcp` - Model Context Protocol SDK
+- `httpx` - Async HTTP client
+- `argclass` - Argument parsing
+- `aiosqlite` - Async SQLite database
+- `pydantic` - Data validation
+
+## Development
+
+**Requirements:** Python 3.10+
+
+```bash
+# Clone and install in dev mode
+git clone https://github.com/nebius/contree-mcp.git
+cd contree-mcp
+uv sync --group dev
+```
+
+### Development Workflow
+
+Follow this sequence when making changes:
+
+1. **Make code changes** - Edit files in `contree_mcp/`
+
+2. **Run tests** - Ensure all tests pass
+   ```bash
+   uv run pytest tests/ -v
+   ```
+
+3. **Run linter** - Fix any style issues
+   ```bash
+   uv run ruff check contree_mcp
+   uv run ruff format contree_mcp  # Auto-fix formatting
+   ```
+
+4. **Type check** (optional but recommended)
+   ```bash
+   uv run mypy contree_mcp
+   ```
+
+5. **Update documentation** - Keep docs in sync with code
+   - `README.md` - User-facing docs, examples, tool descriptions
+   - `llm.txt` - Shared context for AI agents (architecture, class hierarchy, internals)
+
+### Quick Commands
+
+```bash
+# Full validation cycle
+uv run pytest tests/ -q && uv run ruff check contree_mcp && echo "All checks passed"
+
+# Run specific test file
+uv run pytest tests/test_tools/test_run.py -v
+
+# Auto-fix linting issues
+uv run ruff check contree_mcp --fix
+```
+
+### Testing GitHub Actions Locally
+
+Use [act](https://github.com/nektos/act) to run GitHub Actions workflows locally before pushing:
+
+```bash
+# Install act
+brew install act        # macOS
+sudo pacman -S act      # Arch Linux
+sudo apt install act    # Debian/Ubuntu (via nix or manual install)
+
+# List available jobs
+act -l
+
+# Run lint and typecheck jobs (fast)
+act -j lint
+act -j typecheck
+
+# Run tests for Linux only (act simulates Linux)
+act -j test --matrix os:ubuntu-latest
+
+# Run specific Python version
+act -j test --matrix os:ubuntu-latest --matrix python-version:3.12
+
+# Run all jobs sequentially (stop on first failure)
+act -j lint && act -j typecheck && act -j test --matrix os:ubuntu-latest
+
+# Dry run (show what would execute)
+act -n
+```
+
+**Note:** act uses Docker containers that simulate Linux runners. macOS/Windows matrix jobs will run in Linux
+containers, so use `--matrix os:ubuntu-latest` for accurate local testing.
+
+# Copyright
+
+Nebius B.V. 2026, Licensed under the Apache License, Version 2.0 (see "LICENSE" file).

contree_mcp-0.1.0.dist-info/RECORD

@@ -0,0 +1,46 @@
+contree_mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+contree_mcp/__main__.py,sha256=5Tq-hL2bbaZr7-fPQqdAbiidKhyku2xNqX1gZlAEkuk,616
+contree_mcp/app.py,sha256=vQERw5bvgpKviEeHTibO0WA1tfBtj-htxswYDzGRq0Y,9132
+contree_mcp/arguments.py,sha256=AtIO5xx2nqhZHQ2EJ1QS1Z6yVW3k86nHc4tTXcxjpfQ,1047
+contree_mcp/backend_types.py,sha256=Rx_Wn4gtsJ_zR4RB5hSefbO56ljf7BQeJWLGdxknYA0,9375
+contree_mcp/cache.py,sha256=5_ItLP-An1nKHlezlmSgpsA8AwgTPR-uNxcy8PzI4dw,8487
+contree_mcp/client.py,sha256=dXNY7Uc2hcv3XmrCwWfqEG9bjTdHWsIdPdpGxKe3FxI,26506
+contree_mcp/context.py,sha256=YGMXp4FT31MIRBvfihE-YCw5kPkJqTH-a_tTLIrq98o,1749
+contree_mcp/docs.py,sha256=WOciz0aZPLrHNjjRgR61-cSxBbPPCI_BmoF5o5wxeTQ,29436
+contree_mcp/file_cache.py,sha256=ZS9D5MGM2ACblHTidUw2zRSalpfC5NmHv_9uECcqu5M,14055
+contree_mcp/prompts.py,sha256=EzFLqCHWBjpVshvHfmtmB300gb6mpboUp7nVB6Cuokk,8250
+contree_mcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+contree_mcp/server.py,sha256=3D5v-WqzV-HGkPIckDDGQCrSoWZ8CEqeU-QgQYQeVCs,2721
+contree_mcp/auth/__init__.py,sha256=vhtYeBrAl3363anBmk5-Fa23Wdl9m6_1Gn_VKyDK9-E,104
+contree_mcp/auth/registry.py,sha256=3gmV4v_Dn2eYchum56s1gQYl2kSvII_6thvWKz4OyX0,8237
+contree_mcp/resources/__init__.py,sha256=WzGWOxspHVfBhkLLlVDlZU7nsUpntoY3Td_NMNOgNcc,423
+contree_mcp/resources/guide.py,sha256=JEm94_wq1yRJtILDgoXK98eTKvBdFKA19xDJP99pabc,20164
+contree_mcp/resources/image_lineage.py,sha256=CBb5ZOpVTx11RGv06-ToDN3YdcRnZvTaC34HrHfc4xI,1594
+contree_mcp/resources/image_ls.py,sha256=W_DoesnFTLNCwOSmi0j9wtSnpC0xtwzS96RQkhyYq5Q,1108
+contree_mcp/resources/import_operation.py,sha256=ocfnEF0ey4RvI_ia6KA-DlNXdFdYqoPG1_vohXxqago,1572
+contree_mcp/resources/instance_operation.py,sha256=kCHO0fGQ__j136y2LfHf6Ghf5y8rHZJTXxnrl5AeDpA,1939
+contree_mcp/resources/read_file.py,sha256=39kXv1FpAzKYrB67ba_r1IZBE-nGTYdNbuVH0svpwjc,1132
+contree_mcp/resources/static.py,sha256=kHH1u910C1DsorCzVlRm5h6_JPENSE1OU0wvuuNANpg,306
+contree_mcp/tools/__init__.py,sha256=SR3Z22vV_AvXnT58q_3_I4YkLwK1ysdM8dC13Xpe-ok,978
+contree_mcp/tools/cancel_operation.py,sha256=QdGb956PEoy9oYmOIWHuxYlm0hakHg4uv_NIgrX3i9k,1111
+contree_mcp/tools/download.py,sha256=ZpRzRYVwpAA-TMzA1c-2cWaujR1PPdimolc4ZNS3wng,4351
+contree_mcp/tools/get_guide.py,sha256=5PNi_hNXAFCquS5xEZ9fH6_16jchlpT20K1YRJjxn_w,1853
+contree_mcp/tools/get_image.py,sha256=3VipR0OLWkDeggoY4rh-1l8U93s83D_x-wO8R_e0H8c,922
+contree_mcp/tools/get_operation.py,sha256=QDLCR0dmiOSAMI_a1VufQcn2Il2FjJmPCBehIKxzK-0,814
+contree_mcp/tools/import_image.py,sha256=gB4JwXd1jpgVayCYq6ktWKWwwpBG9G7SsQ13fmQE1sk,3884
+contree_mcp/tools/list_files.py,sha256=xMJeQPpkjJVDEnRPiicqYsgPEDbOxOQIzDae-MkjqQo,2202
+contree_mcp/tools/list_images.py,sha256=2Z65nnW2yItGHsh10v7tOwJmUQupp3lnVAzcoMY72Vk,1531
+contree_mcp/tools/list_operations.py,sha256=2p31Xqt4YY_3QSKU2yrOxv4vqS_L-sD4aaGM5Acix8U,1300
+contree_mcp/tools/read_file.py,sha256=f5c88J08rtdFBbCd4o9MU47-qMYX_9ORqYX9OpM-qKw,1328
+contree_mcp/tools/registry_auth.py,sha256=9piWm9fhLhEjngIaMURhLXrnr4h_rpoT21GRi4sQr0w,2066
+contree_mcp/tools/registry_token_obtain.py,sha256=pS2dmXBGJTJRjvheiGDhjjVS1dThqHOmK8UNFKdRsHU,2628
+contree_mcp/tools/rsync.py,sha256=ZE6pbKjclEdsuuaI7pbCg6QfeEj-L2-scWZBmQ7hhQk,1333
+contree_mcp/tools/run.py,sha256=QS-QgLVQB2_-z9kBfYgE0gu-cnu-nLB6w8uyNb_J8QM,3614
+contree_mcp/tools/set_tag.py,sha256=WFlGPSHthOA4UbfjI9FVbA2tZN0p-Qvw_i8x13uefUI,1145
+contree_mcp/tools/upload.py,sha256=IdXDiy8VZENbyu7APYPe7wC2af7QkEVdU4EI2GpdJl0,1566
+contree_mcp/tools/wait_operations.py,sha256=BEexOTYWQ-a5sGxyfKDASHUVFoDiBuqYzo_6JGuw8YA,2745
+contree_mcp-0.1.0.dist-info/METADATA,sha256=ZKfIuWSUzItsucpklEgNcYdK7PiXoTMyRLGlVoJucZE,13141
+contree_mcp-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+contree_mcp-0.1.0.dist-info/entry_points.txt,sha256=Jv9r9PfrtYFtYkYu5usTpZelyQwNbbv_XAivokhcyT8,58
+contree_mcp-0.1.0.dist-info/licenses/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
+contree_mcp-0.1.0.dist-info/RECORD,,

contree_mcp-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

contree_mcp-0.1.0.dist-info/entry_points.txt

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