quartermaster-code-runner 0.0.1__py3-none-any.whl

quartermaster_code_runner/schemas.py

@@ -0,0 +1,154 @@
+"""Pydantic request/response models for code execution API."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from pydantic import BaseModel, field_validator
+
+from quartermaster_code_runner.config import (
+    DEFAULT_IMAGE,
+    PREBUILT_IMAGE_PREFIX,
+    SUPPORTED_IMAGES,
+    get_short_image_name,
+)
+
+
+class PrebuildSpec(BaseModel):
+    """Build recipe for a prebuilt image, used for on-the-fly rebuilds."""
+
+    base_image: str
+    setup_script: str
+
+
+class CodeExecutionRequest(BaseModel):
+    """Request model for code execution.
+
+    Attributes:
+        code: Source code to execute.
+        image: Runtime image (python, node, go, rust, deno, bun).
+        files: Additional files to include {filename: content}.
+        entrypoint: Custom entrypoint command (overrides default).
+        timeout: Execution timeout in seconds.
+        mem_limit: Memory limit (e.g., "256m").
+        cpu_shares: CPU shares (Docker cpu_shares).
+        disk_limit: Disk limit for tmpfs (e.g., "512m").
+        allow_network: Whether to allow outbound network access.
+        environment: Environment variables to inject.
+        prebuild_spec: Optional prebuild specification for on-the-fly rebuilds.
+    """
+
+    code: str
+    image: str = DEFAULT_IMAGE
+    files: Optional[dict[str, str]] = None
+    entrypoint: Optional[str] = None
+    timeout: Optional[int] = None
+    mem_limit: Optional[str] = None
+    cpu_shares: Optional[int] = None
+    disk_limit: Optional[str] = None
+    allow_network: bool = False
+    environment: Optional[dict[str, str]] = None
+    prebuild_spec: Optional[PrebuildSpec] = None
+
+    @field_validator("image")
+    @classmethod
+    def validate_image(cls, v: str) -> str:
+        short_name = get_short_image_name(v)
+        if short_name not in SUPPORTED_IMAGES:
+            full_prebuilt = (
+                v
+                if v.startswith(PREBUILT_IMAGE_PREFIX)
+                else f"{PREBUILT_IMAGE_PREFIX}{v}"
+            )
+            return full_prebuilt
+        return short_name
+
+    @field_validator("environment")
+    @classmethod
+    def validate_environment(
+        cls, v: Optional[dict[str, str]]
+    ) -> Optional[dict[str, str]]:
+        if v is None:
+            return v
+        reserved_keys = {
+            "ENCODED_CODE",
+            "ENCODED_FILES",
+            "CUSTOM_ENTRYPOINT",
+        }
+        for key in v:
+            if key in reserved_keys:
+                raise ValueError(
+                    f"Environment variable '{key}' is reserved and cannot be set."
+                )
+        return v
+
+
+class CodeExecutionResponse(BaseModel):
+    """Response model for code execution."""
+
+    stdout: str
+    stderr: str
+    exit_code: int
+    execution_time: float
+    metadata: Optional[dict[str, object]] = None
+
+
+class PrebuildRequest(BaseModel):
+    """Request model for building a prebuilt image."""
+
+    tag: str
+    base_image: str = DEFAULT_IMAGE
+    setup_script: str
+
+    @field_validator("base_image")
+    @classmethod
+    def validate_base_image(cls, v: str) -> str:
+        short_name = get_short_image_name(v)
+        if short_name not in SUPPORTED_IMAGES:
+            raise ValueError(
+                f"Unsupported base image '{v}'. "
+                f"Supported: {', '.join(SUPPORTED_IMAGES)}"
+            )
+        return short_name
+
+    @field_validator("tag")
+    @classmethod
+    def validate_tag(cls, v: str) -> str:
+        v = v.strip()
+        if not v:
+            raise ValueError("Tag cannot be empty.")
+        if v.startswith(PREBUILT_IMAGE_PREFIX):
+            v = v[len(PREBUILT_IMAGE_PREFIX) :]
+        if not all(c.isalnum() or c in "-_." for c in v):
+            raise ValueError(
+                "Tag must contain only alphanumeric characters, "
+                "hyphens, underscores, or dots."
+            )
+        return v
+
+
+class HealthResponse(BaseModel):
+    """Health check response."""
+
+    status: str
+    docker_connected: bool
+    auth_enabled: bool
+
+
+class RuntimeInfo(BaseModel):
+    """Information about a single runtime."""
+
+    id: str
+    name: str
+    description: str
+    default_entrypoint: str
+    file_extension: str
+    main_file: str
+    completions: list[dict[str, object]] = []
+
+
+class RuntimesResponse(BaseModel):
+    """Response for listing available runtimes."""
+
+    images: list[RuntimeInfo]
+    default: str

quartermaster_code_runner/security.py

@@ -0,0 +1,81 @@
+"""API key authentication middleware.
+
+Supports two modes:
+- API key via X-API-Key header (multiple keys, comma-separated)
+- Bearer token via Authorization header
+
+When no keys/tokens are configured, authentication is disabled and
+all requests are allowed through.
+"""
+
+from __future__ import annotations
+
+import hmac
+from typing import Optional
+
+from fastapi import HTTPException, Request, Security
+from fastapi.security import APIKeyHeader
+
+API_KEY_NAME = "X-API-Key"
+api_key_header = APIKeyHeader(name=API_KEY_NAME, auto_error=False)
+
+# Populated at startup from settings
+_api_keys: list[str] = []
+_auth_token: str | None = None
+_auth_enabled: bool = False
+
+
+def configure_auth(
+    api_keys: list[str] | None = None,
+    auth_token: str | None = None,
+) -> None:
+    """Configure authentication at startup.
+
+    Args:
+        api_keys: List of valid API keys for X-API-Key header.
+        auth_token: Bearer token for Authorization header.
+    """
+    global _api_keys, _auth_token, _auth_enabled
+    _api_keys = list(api_keys) if api_keys else []
+    _auth_token = auth_token
+    _auth_enabled = bool(_api_keys) or bool(_auth_token)
+
+
+async def verify_auth(
+    request: Request,
+    api_key: Optional[str] = Security(api_key_header),
+) -> Optional[str]:
+    """Verify request authentication.
+
+    Checks X-API-Key header first, then Authorization Bearer token.
+    If no auth is configured, allows all requests.
+
+    Returns:
+        The authenticated key/token, or None if auth is disabled.
+
+    Raises:
+        HTTPException: If authentication fails.
+    """
+    if not _auth_enabled:
+        return None
+
+    # Check X-API-Key header
+    if api_key and any(hmac.compare_digest(api_key, k) for k in _api_keys):
+        return api_key
+
+    # Check Authorization Bearer token
+    auth_header = request.headers.get("Authorization", "")
+    if auth_header.startswith("Bearer ") and _auth_token:
+        token = auth_header[7:]
+        if hmac.compare_digest(token, _auth_token):
+            return token
+
+    # If we have an API key but it's invalid
+    if api_key:
+        raise HTTPException(status_code=403, detail="Invalid API Key")
+
+    # No credentials provided
+    raise HTTPException(
+        status_code=401,
+        detail="Not authenticated. Provide X-API-Key header or Authorization Bearer token.",
+    )

quartermaster_code_runner-0.0.1.dist-info/METADATA

@@ -0,0 +1,322 @@
+Metadata-Version: 2.4
+Name: quartermaster-code-runner
+Version: 0.0.1
+Summary: Secure sandboxed code execution service supporting Python, Node.js, Go, Rust, Deno, and Bun via Docker containers
+Project-URL: Homepage, https://github.com/MindMadeLab/quartermaster-sdk-py
+Project-URL: Repository, https://github.com/MindMadeLab/quartermaster-sdk-py
+Project-URL: Issues, https://github.com/MindMadeLab/quartermaster-sdk-py/issues
+Author-email: MindMade <info@mindmade.io>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: agents,ai,code-execution,code-runner,docker,sandbox,security
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Requires-Dist: docker>=7.0.0
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: uvicorn[standard]>=0.20.0
+Provides-Extra: dev
+Requires-Dist: filelock>=3.0; extra == 'dev'
+Requires-Dist: mypy>=1.8; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Requires-Dist: types-docker>=7.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# quartermaster-code-runner
+
+Secure sandboxed code execution service. Runs untrusted code in isolated Docker containers with support for Python, Node.js, Go, Rust, Deno, and Bun.
+
+[![PyPI version](https://img.shields.io/pypi/v/quartermaster-code-runner.svg)](https://pypi.org/project/quartermaster-code-runner/)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11%2B-blue.svg)](https://www.python.org/downloads/)
+[![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-yellow.svg)](https://opensource.org/licenses/Apache-2.0)
+
+## Features
+
+- **6 Runtimes**: Python, Node.js, Go, Rust, Deno, Bun
+- **Docker Isolation**: Each execution runs in its own container with read-only filesystem
+- **Resource Limits**: Configurable CPU, memory, and disk quotas per execution
+- **Network Control**: Outbound network access toggled per request
+- **Timeout Enforcement**: Hard container kill after configurable duration
+- **File Injection**: Send multiple source files alongside the main code
+- **Prebuilt Images**: Extend base runtimes with custom dependencies
+- **Auto Cleanup**: Orphaned containers and old images cleaned up automatically
+- **API Key Auth**: Optional authentication via `X-API-Key` header or Bearer token
+- **Health Checks**: Built-in `/health` endpoint with Docker connectivity status
+- **Standalone**: No dependency on other Quartermaster packages
+
+## Supported Runtimes
+
+| Runtime | Image Name | Sandbox |
+|---------|-----------|---------|
+| Python | `python` | Alpine Linux |
+| Node.js | `node` | Alpine Linux |
+| Go | `go` | Alpine Linux |
+| Rust | `rust` | Alpine Linux |
+| Deno | `deno` | Alpine Linux |
+| Bun | `bun` | Alpine Linux |
+
+## Installation
+
+### As a Service (recommended)
+
+```bash
+pip install quartermaster-code-runner
+uvicorn quartermaster_code_runner.app:app --host 0.0.0.0 --port 8000
+```
+
+Requires Docker to be running and accessible.
+
+### Docker Compose
+
+```yaml
+services:
+  code-runner:
+    build: .
+    ports:
+      - "8000:8000"
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+    environment:
+      - LOG_LEVEL=info
+      - DEFAULT_TIMEOUT=30
+      - DEFAULT_MEMORY=256m
+```
+
+## Quick Start
+
+### Execute Python Code
+
+```bash
+curl -X POST http://localhost:8000/run \
+  -H "Content-Type: application/json" \
+  -d '{
+    "code": "print(sum(range(1, 101)))",
+    "image": "python"
+  }'
+```
+
+Response:
+
+```json
+{
+  "stdout": "5050\n",
+  "stderr": "",
+  "exit_code": 0,
+  "execution_time": 0.3421
+}
+```
+
+### Execute Node.js Code
+
+```bash
+curl -X POST http://localhost:8000/run \
+  -H "Content-Type: application/json" \
+  -d '{
+    "code": "console.log(Array.from({length: 5}, (_, i) => i * i))",
+    "image": "node"
+  }'
+```
+
+### With Environment Variables and Resource Limits
+
+```bash
+curl -X POST http://localhost:8000/run \
+  -H "Content-Type: application/json" \
+  -d '{
+    "code": "import os; print(os.environ[\"API_KEY\"])",
+    "image": "python",
+    "timeout": 10,
+    "mem_limit": "128m",
+    "cpu_shares": 256,
+    "allow_network": false,
+    "environment": {
+      "API_KEY": "secret-123"
+    }
+  }'
+```
+
+### With Additional Files
+
+```bash
+curl -X POST http://localhost:8000/run \
+  -H "Content-Type: application/json" \
+  -d '{
+    "code": "from helpers import greet; print(greet(\"world\"))",
+    "image": "python",
+    "files": {
+      "helpers.py": "def greet(name): return f\"Hello, {name}!\""
+    }
+  }'
+```
+
+### Python Client Usage
+
+```python
+from quartermaster_code_runner import CodeExecutionRequest
+
+request = CodeExecutionRequest(
+    code="print('Hello from the sandbox')",
+    image="python",
+    timeout=10,
+    mem_limit="128m",
+    allow_network=False,
+)
+```
+
+## API Reference
+
+### POST /run
+
+Execute code in a sandboxed Docker container.
+
+**Request body** (`CodeExecutionRequest`):
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `code` | `string` | required | Source code to execute |
+| `image` | `string` | `"python"` | Runtime: `python`, `node`, `go`, `rust`, `deno`, `bun` |
+| `files` | `dict[str, str]` | `null` | Additional files `{filename: content}` |
+| `entrypoint` | `string` | `null` | Custom entrypoint command |
+| `timeout` | `int` | `null` (uses server default) | Execution timeout in seconds |
+| `mem_limit` | `string` | `null` (uses server default) | Memory limit, e.g. `"256m"` |
+| `cpu_shares` | `int` | `null` (uses server default) | Docker CPU shares |
+| `disk_limit` | `string` | `null` (uses server default) | Disk limit for tmpfs |
+| `allow_network` | `bool` | `true` | Allow outbound network access |
+| `environment` | `dict[str, str]` | `null` | Environment variables to inject |
+| `prebuild_spec` | `object` | `null` | Prebuild spec: `{base_image, setup_script}` |
+
+**Response** (`CodeExecutionResponse`):
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `stdout` | `string` | Standard output |
+| `stderr` | `string` | Standard error |
+| `exit_code` | `int` | Process exit code |
+| `execution_time` | `float` | Wall-clock time in seconds |
+| `metadata` | `dict` | Optional metadata from the container |
+
+### GET /health
+
+Returns service health and Docker connectivity.
+
+```json
+{
+  "status": "ok",
+  "docker_connected": true,
+  "auth_enabled": false
+}
+```
+
+### GET /runtimes
+
+List available runtime images with metadata (alias for `/images`).
+
+```json
+{
+  "images": [
+    {
+      "id": "code-runner-python",
+      "name": "Python",
+      "description": "Python runtime",
+      "default_entrypoint": "python main.py",
+      "file_extension": ".py",
+      "main_file": "main.py"
+    }
+  ],
+  "default": "code-runner-python"
+}
+```
+
+### POST /prebuild
+
+Build a prebuilt image extending a base runtime with custom dependencies.
+
+```bash
+curl -X POST http://localhost:8000/prebuild \
+  -H "Content-Type: application/json" \
+  -d '{
+    "tag": "my-scipy",
+    "base_image": "python",
+    "setup_script": "pip install scipy numpy"
+  }'
+```
+
+### GET /prebuilds
+
+List all prebuilt images. `DELETE /prebuilds/{tag}` removes one.
+
+## Security Model
+
+Each execution is isolated with multiple layers:
+
+1. **Container isolation** -- separate Docker container per execution
+2. **Read-only filesystem** -- containers run with `read_only=True`; writes go to tmpfs
+3. **Network control** -- outbound access disabled when `allow_network=false`
+4. **Resource limits** -- CPU shares, memory limit, disk quota enforced by Docker
+5. **Timeout enforcement** -- containers killed after the configured timeout
+6. **Input validation** -- code size capped at 1 MB; reserved env vars blocked; path traversal rejected
+
+Reserved environment variables (`ENCODED_CODE`, `ENCODED_FILES`, `CUSTOM_ENTRYPOINT`) cannot be overridden by callers.
+
+## Configuration
+
+All settings load from environment variables with sensible defaults. Use a `.env` file or set them directly.
+
+### Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `HOST` | `0.0.0.0` | Bind address |
+| `PORT` | `8000` | Bind port |
+| `LOG_LEVEL` | `info` | Log level (`debug`, `info`, `warning`, `error`) |
+| `DEFAULT_TIMEOUT` | `30` | Default execution timeout (seconds) |
+| `MAX_TIMEOUT` | `300` | Hard maximum timeout (seconds) |
+| `DEFAULT_MEMORY` | `256m` | Default memory limit |
+| `MAX_MEMORY_MB` | `2048` | Maximum memory (MB) |
+| `DEFAULT_CPU_SHARES` | `512` | Default Docker CPU shares |
+| `MAX_CPU_CORES` | `4.0` | Maximum CPU cores |
+| `DEFAULT_DISK` | `512m` | Default tmpfs disk limit |
+| `MAX_DISK_MB` | `5000` | Maximum disk (MB) |
+| `DOCKER_SOCKET` | `/var/run/docker.sock` | Docker socket path |
+| `AUTH_TOKEN` | _(none)_ | Bearer token for authentication |
+| `CODE_RUNNER_API_KEYS` | _(none)_ | Comma-separated API keys for `X-API-Key` header |
+| `CLEANUP_INTERVAL_HOURS` | `24` | Hours between automatic prebuild cleanup |
+| `CLEANUP_MAX_AGE_DAYS` | `7` | Max age (days) for prebuilt images before cleanup |
+| `RUNTIME_DIR` | _(auto)_ | Path to runtime Dockerfile directories |
+
+When neither `AUTH_TOKEN` nor `CODE_RUNNER_API_KEYS` is set, authentication is disabled.
+
+### Error Types
+
+```python
+from quartermaster_code_runner import (
+    CodeRunnerError,          # Base exception
+    DockerError,              # Docker communication failure
+    ExecutionError,           # Code execution failure
+    InvalidLanguageError,     # Unsupported runtime
+    ResourceExhaustedError,   # Resource limit exceeded
+    RuntimeNotAvailableError, # Runtime image not found
+    TimeoutError,             # Execution timeout
+)
+```
+
+## Contributing
+
+Contributions welcome. See [CONTRIBUTING.md](../CONTRIBUTING.md) for guidelines.
+
+## License
+
+Apache License 2.0. See [LICENSE](../LICENSE) for details.

quartermaster_code_runner-0.0.1.dist-info/RECORD

@@ -0,0 +1,40 @@
+quartermaster_code_runner/__init__.py,sha256=JGQbVP4IjEaknzHm5MffiJZ6jpCjtclxzyEq-IK5YCc,921
+quartermaster_code_runner/app.py,sha256=o7tZ7TO0QWpWCSR98aOzLm72p1KryW5-MXLrpcu4GHY,7956
+quartermaster_code_runner/config.py,sha256=4Y_uCigeVI-HZpls79eSDi0IvZjKH9-eioUQ7dVvOHE,5722
+quartermaster_code_runner/errors.py,sha256=8TXnhLjbq-oxaxYUphtZafCqMan8zGqC7c_50hTv_K0,2112
+quartermaster_code_runner/execution.py,sha256=1GITLL7_KPM1tgjZRgbttvKPO4wKAUoNACE9XeSoFrw,7539
+quartermaster_code_runner/images.py,sha256=GTswsz2adF1ckPiumoMG5zsc3o5SNPMlz9I69j65Ao8,12255
+quartermaster_code_runner/schemas.py,sha256=afljp0QqmigWtL98w7xS14Obk7tIKUIyHmdcHv6kVZQ,4344
+quartermaster_code_runner/security.py,sha256=PjOJwmDM7tGvc6_PG7yQn9aD3IpvDe7dRjZw9DpbR84,2321
+quartermaster_code_runner/runtime/bun/Dockerfile,sha256=TqfFRomPZDTOXqnLr3OoGQCvMq1aFNDD1pR80weXGHQ,552
+quartermaster_code_runner/runtime/bun/completions.json,sha256=XGGmMUlQtR1xaH8XRO2-3XJmJ8m33zx2pUzWVOA4Cbc,1010
+quartermaster_code_runner/runtime/bun/entrypoint.sh,sha256=JBAp3A2qW7GyGDUqbaiI3hzud6YLElttFRNefSSgvIY,730
+quartermaster_code_runner/runtime/bun/sdk.ts,sha256=50yeEuzjxkYxM1V_iVXRGwp87bK2JAV_Pe4ekugztH8,2527
+quartermaster_code_runner/runtime/deno/Dockerfile,sha256=O4IRPBZezD65W0MOlw7-2Y-Kb2FvnSHVRwiQyXb4Fug,581
+quartermaster_code_runner/runtime/deno/completions.json,sha256=1ZNOI_q7wdzpqnQUBzddws1EQtd7gjhaOJFNf7ILOG0,1028
+quartermaster_code_runner/runtime/deno/entrypoint.sh,sha256=3qy3yni0Vx26b2j9qDmMyTI5X7U3Xp99yVRgfHDaPA8,790
+quartermaster_code_runner/runtime/deno/sdk.ts,sha256=4XlAqOXoUYnEfXEOCCu5gmxBbwaBqywvwdsMmZTOsbI,2547
+quartermaster_code_runner/runtime/go/Dockerfile,sha256=TuUdzlKMxUE4DAcQVQ2U62FjrlTLoujOj9iajSTS4f8,373
+quartermaster_code_runner/runtime/go/completions.json,sha256=U9RqmoFWH3BaXZQQZBvmoQqj2XsKAl0g1GHz-GMu0dE,654
+quartermaster_code_runner/runtime/go/entrypoint.sh,sha256=So4SfF9TUbREvvD28DYEuWq4qoWvdpG9W-E6EBn-PE8,1158
+quartermaster_code_runner/runtime/go/sdk.go,sha256=wPQO8pEfYpez2Vk7CeH6xtyROeaE5xyUMUb2iZDsvbg,2749
+quartermaster_code_runner/runtime/node/Dockerfile,sha256=OsNWW5yiPpzm7HPmHvQPlCUrmj7zlF81pYNSxgSoLjM,865
+quartermaster_code_runner/runtime/node/completions.json,sha256=gFqm6zHJFle58qcjfzIRgM9l8K5taatAiNww77F7oaU,1040
+quartermaster_code_runner/runtime/node/entrypoint.sh,sha256=ocF3ZmyKdf8UF0W-6lfy92oTT6Nfy-CYxUuI6pF565I,788
+quartermaster_code_runner/runtime/node/mcp-client.js,sha256=u_I9RCDAsaXfUrMMh4IIViswIDwS2WDVviGVIWqABHM,7478
+quartermaster_code_runner/runtime/node/sdk.js,sha256=gaxpnRvSQlieGK3Sb_CMFiG6KTrU_VEo1aDXai1gA2Y,3735
+quartermaster_code_runner/runtime/python/Dockerfile,sha256=G7rB7o3dcJ1ao5yhuwuBMnCJosNu_rtsXTdjoJSc8LM,1082
+quartermaster_code_runner/runtime/python/completions.json,sha256=8TzaFwd0rGrEezTJtQS5Eo2BCWZcOSTdu6vCev5Dgro,971
+quartermaster_code_runner/runtime/python/entrypoint.sh,sha256=zlB-MTfRaDBn7y7oxUMCxuzqwaWkox4v_EHKkIkw1zQ,663
+quartermaster_code_runner/runtime/python/mcp-client.py,sha256=sFYP6A9e6adnZhe8kWokCqWIlhkbcy4tLSmC0feBxcw,9256
+quartermaster_code_runner/runtime/python/sdk.py,sha256=q8EWYjNj7aZFnapcNdg8PE-nTEgDEufzi5d-aqgWM3c,2885
+quartermaster_code_runner/runtime/rust/Cargo.toml.default,sha256=xvpoOpuOy2feL7R85bXW__304gX0GvHTouCm1hm5nm0,178
+quartermaster_code_runner/runtime/rust/Dockerfile,sha256=MA6oXGB-9ywPoZ20OQInZtOmsbh11sqR_RLUbLplaaw,707
+quartermaster_code_runner/runtime/rust/completions.json,sha256=_64n1o3bHW0v1GWw7-pa91LeCeFrjkU3UVAvz7JGE6c,992
+quartermaster_code_runner/runtime/rust/entrypoint.sh,sha256=zy3Wq1OHhMkbfwbSemheKkhhfArIuSYtizUHLJkY8eA,969
+quartermaster_code_runner/runtime/rust/sdk/Cargo.toml,sha256=EsV1PlN0GYlJx6sphZQRh0VAQeGbijQx1om7LjOxpog,155
+quartermaster_code_runner/runtime/rust/sdk/src/lib.rs,sha256=90CPtVKBXlIIewyvuAT34wWFxB7k2gDf_TzjGUtlFvY,4074
+quartermaster_code_runner-0.0.1.dist-info/METADATA,sha256=opoD6hGzmMpKB9ZtrCkngKXDixEsOhYpL9JwalUeWcw,10352
+quartermaster_code_runner-0.0.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+quartermaster_code_runner-0.0.1.dist-info/licenses/LICENSE,sha256=E-YezCKmkJWerKMBOH9wLYcgDTX9MPImxNow_EwXsTs,10766
+quartermaster_code_runner-0.0.1.dist-info/RECORD,,

quartermaster_code_runner-0.0.1.dist-info/WHEEL

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