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

quartermaster_code_runner/runtime/python/mcp-client.py

@@ -0,0 +1,276 @@
+#!/usr/bin/env python3
+"""
+MCP Stdio Client - Executes MCP server commands and calls tools via stdio transport
+
+Environment variables:
+- MCP_COMMAND: The command to start the MCP server (e.g., "uvx mcp-server-fetch")
+- MCP_OPERATION: The operation to perform: "list_tools" or "call_tool" (default: "call_tool")
+- MCP_TOOL_NAME: The name of the tool to call (required for call_tool operation)
+- MCP_TOOL_ARGUMENTS: JSON string of arguments to pass to the tool
+- MCP_ENV_*: Additional environment variables to pass to the MCP server (prefix stripped)
+"""
+
+import json
+import os
+import subprocess
+import sys
+import threading
+from typing import Any
+
+MCP_PROTOCOL_VERSION = "2024-11-05"
+INITIALIZE_TIMEOUT = 60  # 60 seconds for slow package resolution
+TOOL_CALL_TIMEOUT = 120
+
+
+class McpStdioClient:
+    def __init__(self, command: str, server_env: dict[str, str] | None = None):
+        self.command = command
+        self.server_env = server_env or {}
+        self.process: subprocess.Popen | None = None
+        self.message_id = 0
+        self.pending_requests: dict[int, dict] = {}
+        self.initialized = False
+        self._lock = threading.Lock()
+        self._response_event = threading.Event()
+        self._reader_thread: threading.Thread | None = None
+        self._stderr_thread: threading.Thread | None = None
+        self._exit_thread: threading.Thread | None = None
+        self._last_response: dict | None = None
+        self._server_stderr_lines: list[str] = []
+        self._process_exited = False
+        self._exit_code: int | None = None
+
+    def start(self):
+        env = os.environ.copy()
+        env.update(self.server_env)
+
+        for key in ["MCP_COMMAND", "MCP_TOOL_NAME", "MCP_TOOL_ARGUMENTS"]:
+            env.pop(key, None)
+
+        self.process = subprocess.Popen(
+            self.command,
+            shell=True,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            env=env,
+            text=True,
+            bufsize=1,
+        )
+
+        self._reader_thread = threading.Thread(target=self._read_responses, daemon=True)
+        self._reader_thread.start()
+        self._stderr_thread = threading.Thread(target=self._read_stderr, daemon=True)
+        self._stderr_thread.start()
+        self._exit_thread = threading.Thread(target=self._monitor_exit, daemon=True)
+        self._exit_thread.start()
+
+    def _monitor_exit(self):
+        if not self.process:
+            return
+        self._exit_code = self.process.wait()
+        self._process_exited = True
+        self._response_event.set()
+
+    def _read_stderr(self):
+        if not self.process or not self.process.stderr:
+            return
+        for line in self.process.stderr:
+            line = line.rstrip("\n")
+            self._server_stderr_lines.append(line)
+            print(f"[MCP Server] {line}", file=sys.stderr)
+
+    def _read_responses(self):
+        if not self.process or not self.process.stdout:
+            return
+
+        for line in self.process.stdout:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                message = json.loads(line)
+                self._handle_message(message)
+            except json.JSONDecodeError:
+                print(f"[MCP Server stdout] {line}", file=sys.stderr)
+
+    def _handle_message(self, message: dict):
+        msg_id = message.get("id")
+        if msg_id is not None and msg_id in self.pending_requests:
+            with self._lock:
+                self._last_response = message
+                self._response_event.set()
+
+    def _send_request(
+        self, method: str, params: dict | None = None, timeout: int = 30
+    ) -> Any:
+        self.message_id += 1
+        request_id = self.message_id
+
+        request = {
+            "jsonrpc": "2.0",
+            "id": request_id,
+            "method": method,
+            "params": params or {},
+        }
+
+        with self._lock:
+            self.pending_requests[request_id] = {}
+            self._response_event.clear()
+            self._last_response = None
+
+        if self._process_exited:
+            raise RuntimeError(
+                f"MCP server exited with code {self._exit_code} before {method} could be sent"
+            )
+
+        if self.process and self.process.stdin:
+            self.process.stdin.write(json.dumps(request) + "\n")
+            self.process.stdin.flush()
+
+        if not self._response_event.wait(timeout):
+            raise TimeoutError(f"{method} timed out after {timeout}s")
+
+        if self._process_exited and self._last_response is None:
+            stderr_tail = "\n".join(self._server_stderr_lines[-20:])
+            raise RuntimeError(
+                f"MCP server process exited with code {self._exit_code} during {method}.\n"
+                f"Server output:\n{stderr_tail}"
+            )
+
+        with self._lock:
+            response = self._last_response
+            self.pending_requests.pop(request_id, None)
+
+        if response and "error" in response:
+            error = response["error"]
+            raise Exception(error.get("message", str(error)))
+
+        return response.get("result") if response else None
+
+    def _send_notification(self, method: str, params: dict | None = None):
+        notification = {
+            "jsonrpc": "2.0",
+            "method": method,
+            "params": params or {},
+        }
+
+        if self.process and self.process.stdin:
+            self.process.stdin.write(json.dumps(notification) + "\n")
+            self.process.stdin.flush()
+
+    def initialize(self) -> dict:
+        result = self._send_request(
+            "initialize",
+            {
+                "protocolVersion": MCP_PROTOCOL_VERSION,
+                "capabilities": {},
+                "clientInfo": {
+                    "name": "quartermaster-code-runner",
+                    "version": "1.0.0",
+                },
+            },
+            timeout=INITIALIZE_TIMEOUT,
+        )
+
+        self._send_notification("notifications/initialized")
+        self.initialized = True
+        return result
+
+    def list_tools(self) -> list[dict]:
+        result = self._send_request("tools/list", {})
+        return result.get("tools", []) if result else []
+
+    def call_tool(self, name: str, arguments: dict | None = None) -> str:
+        result = self._send_request(
+            "tools/call",
+            {"name": name, "arguments": arguments or {}},
+            timeout=TOOL_CALL_TIMEOUT,
+        )
+
+        content = result.get("content", []) if result else []
+        text_parts = []
+
+        for item in content:
+            if item.get("type") == "text":
+                text_parts.append(item.get("text", ""))
+            elif item.get("type") == "image":
+                text_parts.append(f"[Image: {item.get('mimeType', 'unknown')}]")
+            elif item.get("type") == "resource":
+                text_parts.append(f"[Resource: {item.get('uri', 'unknown')}]")
+
+        return "\n".join(text_parts)
+
+    def close(self):
+        if self.process:
+            self.process.terminate()
+            try:
+                self.process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                self.process.kill()
+
+
+def main():
+    command = os.environ.get("MCP_COMMAND")
+    operation = os.environ.get("MCP_OPERATION", "call_tool")
+    tool_name = os.environ.get("MCP_TOOL_NAME")
+    tool_arguments_json = os.environ.get("MCP_TOOL_ARGUMENTS", "{}")
+
+    if not command:
+        print(
+            "Error: MCP_COMMAND environment variable is required",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    if operation == "call_tool" and not tool_name:
+        print(
+            "Error: MCP_TOOL_NAME environment variable is required for call_tool operation",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    try:
+        tool_arguments = json.loads(tool_arguments_json)
+    except json.JSONDecodeError:
+        print("Error: MCP_TOOL_ARGUMENTS must be valid JSON", file=sys.stderr)
+        sys.exit(1)
+
+    server_env = {}
+    for key, value in os.environ.items():
+        if key.startswith("MCP_ENV_"):
+            server_env[key[8:]] = value
+
+    client = McpStdioClient(command, server_env)
+
+    try:
+        print(f"Starting MCP server: {command}", file=sys.stderr)
+        client.start()
+
+        print("Initializing MCP connection...", file=sys.stderr)
+        client.initialize()
+
+        if operation == "list_tools":
+            print("Listing tools...", file=sys.stderr)
+            tools = client.list_tools()
+            print(json.dumps(tools))
+        else:
+            print(f"Calling tool: {tool_name}", file=sys.stderr)
+            result = client.call_tool(tool_name or "", tool_arguments)
+            print(result)
+
+        client.close()
+        sys.exit(0)
+    except Exception as error:
+        print(f"MCP Error: {error}", file=sys.stderr)
+        if client._server_stderr_lines:
+            print("--- MCP Server stderr ---", file=sys.stderr)
+            for line in client._server_stderr_lines:
+                print(line, file=sys.stderr)
+            print("--- End server stderr ---", file=sys.stderr)
+        client.close()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

quartermaster_code_runner/runtime/python/sdk.py

@@ -0,0 +1,103 @@
+"""quartermaster-code-runner SDK for Python runtime."""
+
+import json
+import os
+import urllib.error
+import urllib.request
+
+_METADATA_FILE = "/metadata/.quartermaster_metadata.json"
+
+
+def set_metadata(data):
+    """
+    Set the result metadata to be returned to the backend.
+
+    This separates structured results from stdout/stderr logs.
+
+    Args:
+        data: Any JSON-serializable data (dict, list, str, int, etc.)
+
+    Example:
+        from sdk import set_metadata
+
+        result = {"status": "success", "count": 42}
+        set_metadata(result)
+    """
+    with open(_METADATA_FILE, "w") as f:
+        json.dump(data, f)
+
+
+def get_metadata():
+    """
+    Get previously set metadata (useful for reading/modifying).
+
+    Returns:
+        The previously set metadata, or None if not set.
+    """
+    if not os.path.exists(_METADATA_FILE):
+        return None
+    with open(_METADATA_FILE, "r") as f:
+        return json.load(f)
+
+
+def load_file(path):
+    """Load a file from the flow's environment.
+
+    Only available during flow execution, not test runs.
+
+    Args:
+        path: Path to the file within the environment.
+
+    Returns:
+        The file content as a string.
+
+    Example:
+        from sdk import load_file
+
+        content = load_file("data/config.json")
+    """
+    webdav_url = os.environ.get("QM_WEBDAV_URL")
+    if not webdav_url:
+        raise RuntimeError(
+            "load_file() is only available during flow execution. "
+            "For test runs, use mounted environments instead."
+        )
+    url = webdav_url.rstrip("/") + "/" + path.lstrip("/")
+    req = urllib.request.Request(url, method="GET")
+    try:
+        with urllib.request.urlopen(req) as resp:
+            return resp.read().decode("utf-8")
+    except urllib.error.HTTPError as e:
+        if e.code == 404:
+            raise FileNotFoundError(f"File not found: {path}")
+        raise RuntimeError(f"Failed to load file: {e}")
+
+
+def save_file(path, content):
+    """Save a file to the flow's environment.
+
+    Only available during flow execution, not test runs.
+
+    Args:
+        path: Path to the file within the environment.
+        content: The file content to save.
+
+    Example:
+        from sdk import save_file
+
+        save_file("output/result.txt", "Hello, world!")
+    """
+    webdav_url = os.environ.get("QM_WEBDAV_URL")
+    if not webdav_url:
+        raise RuntimeError(
+            "save_file() is only available during flow execution. "
+            "For test runs, use mounted environments instead."
+        )
+    url = webdav_url.rstrip("/") + "/" + path.lstrip("/")
+    data = content.encode("utf-8")
+    req = urllib.request.Request(url, data=data, method="PUT")
+    req.add_header("Content-Type", "application/octet-stream")
+    try:
+        urllib.request.urlopen(req)
+    except urllib.error.HTTPError as e:
+        raise RuntimeError(f"Failed to save file: {e}")

quartermaster_code_runner/runtime/rust/Cargo.toml.default

@@ -0,0 +1,9 @@
+[package]
+name = "user_code"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+sdk = { path = "/app/sdk" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"

quartermaster_code_runner/runtime/rust/Dockerfile

@@ -0,0 +1,27 @@
+FROM rust:1.87-slim
+
+LABEL qm.name="Rust"
+LABEL qm.description="Rust 1.87 with Cargo"
+LABEL qm.default_entrypoint="cargo run"
+LABEL qm.file_extension=".rs"
+LABEL qm.main_file="src/main.rs"
+
+WORKDIR /app
+
+RUN apt-get update && \
+    apt-get install -y tar && \
+    rm -rf /var/lib/apt/lists/* && \
+    useradd --uid 1001 --no-create-home --shell /bin/sh runner && \
+    mkdir -p /home/runner/.cargo && \
+    chown -R runner:runner /home/runner
+
+# Pre-compile SDK with serde to cache dependencies
+COPY sdk/ /app/sdk/
+RUN cd /app/sdk && cargo build --release && \
+    chown -R runner:runner /app/sdk
+
+COPY Cargo.toml.default .
+COPY entrypoint.sh .
+RUN chmod +x entrypoint.sh
+
+ENTRYPOINT ["/app/entrypoint.sh"]

quartermaster_code_runner/runtime/rust/completions.json

@@ -0,0 +1,34 @@
+[
+    {
+        "caption": "use sdk::set_metadata",
+        "value": "use sdk::set_metadata;",
+        "meta": "import",
+        "score": 1000
+    },
+    {
+        "caption": "use sdk::get_metadata",
+        "value": "use sdk::get_metadata;",
+        "meta": "import",
+        "score": 1000
+    },
+    {
+        "caption": "use sdk::{set_metadata, get_metadata}",
+        "value": "use sdk::{set_metadata, get_metadata};",
+        "meta": "import",
+        "score": 1000
+    },
+    {
+        "caption": "set_metadata",
+        "snippet": "set_metadata(&$1).unwrap()",
+        "meta": "sdk",
+        "score": 1000,
+        "docText": "Set structured result metadata to be returned to the backend. Accepts any Serialize type."
+    },
+    {
+        "caption": "get_metadata",
+        "snippet": "get_metadata::<$1>().unwrap()",
+        "meta": "sdk",
+        "score": 1000,
+        "docText": "Get previously set metadata, deserializing into the specified type. Returns None if not set."
+    }
+]

quartermaster_code_runner/runtime/rust/entrypoint.sh

@@ -0,0 +1,38 @@
+#!/bin/sh
+set -e
+
+chown runner:runner /tmp
+chown runner:runner /metadata 2>/dev/null || true
+chown runner:runner /workspace 2>/dev/null || true
+
+exec su --preserve-environment -s /bin/sh -c '
+    set -e
+    cd /workspace
+    export HOME=/workspace
+    export CARGO_HOME=/workspace/.cargo
+    mkdir -p $CARGO_HOME
+
+    # Decode code to default filename
+    if [ -n "$ENCODED_CODE" ]; then
+        echo "$ENCODED_CODE" | base64 -d > main.rs
+    fi
+
+    # Extract additional files if provided
+    if [ -n "$ENCODED_FILES" ]; then
+        echo "$ENCODED_FILES" | base64 -d | tar -xz
+    fi
+
+    # Copy default Cargo.toml if user did not provide one
+    if [ ! -f Cargo.toml ]; then
+        cp /app/Cargo.toml.default Cargo.toml
+    fi
+
+    # Execute custom entrypoint or default
+    if [ -n "$CUSTOM_ENTRYPOINT" ]; then
+        exec sh -c "$CUSTOM_ENTRYPOINT"
+    else
+        mkdir -p src
+        mv main.rs src/main.rs
+        exec cargo run --release -q
+    fi
+' runner

quartermaster_code_runner/runtime/rust/sdk/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "sdk"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+ureq = "2"

quartermaster_code_runner/runtime/rust/sdk/src/lib.rs

@@ -0,0 +1,149 @@
+//! quartermaster-code-runner SDK for Rust runtime.
+//!
+//! # Example
+//!
+//! ```rust
+//! use sdk::set_metadata;
+//! use serde::Serialize;
+//!
+//! #[derive(Serialize)]
+//! struct Result {
+//!     status: String,
+//!     count: i32,
+//! }
+//!
+//! fn main() {
+//!     let result = Result { status: "success".into(), count: 42 };
+//!     set_metadata(&result).unwrap();
+//! }
+//! ```
+
+use serde::de::DeserializeOwned;
+use serde::Serialize;
+use std::env;
+use std::fs;
+use std::io;
+
+const METADATA_FILE: &str = "/metadata/.quartermaster_metadata.json";
+
+/// Set the result metadata to be returned to the backend.
+///
+/// This separates structured results from stdout/stderr logs.
+///
+/// # Example
+///
+/// ```rust
+/// use sdk::set_metadata;
+/// use serde_json::json;
+///
+/// 
+/// set_metadata(&json!({"status": "success", "count": 42})).unwrap();
+/// ```
+pub fn set_metadata<T: Serialize>(data: &T) -> io::Result<()> {
+    let json =
+        serde_json::to_string(data).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+    fs::write(METADATA_FILE, json)
+}
+
+/// Set metadata from a raw JSON string.
+///
+/// Use this if you already have JSON as a string.
+///
+/// # Example
+///
+/// ```rust
+/// sdk::set_metadata_raw(r#"{"status": "success"}"#).unwrap();
+/// ```
+pub fn set_metadata_raw(json: &str) -> io::Result<()> {
+    fs::write(METADATA_FILE, json)
+}
+
+/// Get previously set metadata, deserializing into the specified type.
+///
+/// Returns `None` if no metadata has been set.
+pub fn get_metadata<T: DeserializeOwned>() -> io::Result<Option<T>> {
+    match fs::read_to_string(METADATA_FILE) {
+        Ok(content) => {
+            let data = serde_json::from_str(&content)
+                .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+            Ok(Some(data))
+        }
+        Err(e) if e.kind() == io::ErrorKind::NotFound => Ok(None),
+        Err(e) => Err(e),
+    }
+}
+
+/// Get previously set metadata as a raw JSON string.
+///
+/// Returns `None` if no metadata has been set.
+pub fn get_metadata_raw() -> io::Result<Option<String>> {
+    match fs::read_to_string(METADATA_FILE) {
+        Ok(content) => Ok(Some(content)),
+        Err(e) if e.kind() == io::ErrorKind::NotFound => Ok(None),
+        Err(e) => Err(e),
+    }
+}
+
+fn webdav_url(path: &str) -> Result<String, io::Error> {
+    let base = env::var("QM_WEBDAV_URL").map_err(|_| {
+        io::Error::new(
+            io::ErrorKind::NotFound,
+            "load_file/save_file is only available during flow execution. \
+             For test runs, use mounted environments instead.",
+        )
+    })?;
+    Ok(format!(
+        "{}/{}",
+        base.trim_end_matches('/'),
+        path.trim_start_matches('/')
+    ))
+}
+
+/// Load a file from the flow's environment.
+///
+/// Only available during flow execution, not test runs.
+///
+/// # Example
+///
+/// ```rust,no_run
+/// let content = sdk::load_file("data/config.json").unwrap();
+/// println!("{}", content);
+/// ```
+pub fn load_file(path: &str) -> io::Result<String> {
+    let url = webdav_url(path)?;
+    let resp = ureq::get(&url).call().map_err(|e| match &e {
+        ureq::Error::Status(404, _) => io::Error::new(
+            io::ErrorKind::NotFound,
+            format!("File not found: {}", path),
+        ),
+        _ => io::Error::new(
+            io::ErrorKind::Other,
+            format!("Failed to load file: {}", e),
+        ),
+    })?;
+    resp.into_string()
+        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))
+}
+
+/// Save a file to the flow's environment.
+///
+/// Only available during flow execution, not test runs.
+///
+/// # Example
+///
+/// ```rust,no_run
+/// sdk::save_file("output/result.txt", "Hello, world!").unwrap();
+/// ```
+pub fn save_file(path: &str, content: &str) -> io::Result<()> {
+    let url = webdav_url(path)?;
+    ureq::put(&url)
+        .set("Content-Type", "application/octet-stream")
+        .send_string(content)
+        .map_err(|e| {
+            io::Error::new(
+                io::ErrorKind::Other,
+                format!("Failed to save file: {}", e),
+            )
+        })?;
+    Ok(())
+}