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

quartermaster_code_runner/runtime/node/mcp-client.js

@@ -0,0 +1,274 @@
+/**
+ * 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., "npx @modelcontextprotocol/server-slack")
+ * - 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)
+ */
+
+const { spawn } = require("child_process");
+const readline = require("readline");
+
+const MCP_PROTOCOL_VERSION = "2024-11-05";
+const INITIALIZE_TIMEOUT = 60000; // 60 seconds for slow package resolution
+const TOOL_CALL_TIMEOUT = 120000; // 2 minutes
+
+class McpStdioClient {
+  constructor(command, serverEnv = {}) {
+    this.command = command;
+    this.serverEnv = serverEnv;
+    this.process = null;
+    this.messageId = 0;
+    this.pendingRequests = new Map();
+    this.initialized = false;
+    this.serverStderrLines = [];
+    this.processExited = false;
+    this.exitCode = null;
+  }
+
+  async start() {
+    return new Promise((resolve, reject) => {
+      const env = {
+        ...process.env,
+        ...this.serverEnv,
+      };
+
+      delete env.MCP_COMMAND;
+      delete env.MCP_TOOL_NAME;
+      delete env.MCP_TOOL_ARGUMENTS;
+
+      this.process = spawn(this.command, {
+        stdio: ["pipe", "pipe", "pipe"],
+        env,
+        shell: true,
+      });
+
+      this.process.on("error", (err) => {
+        reject(new Error(`Failed to start MCP server: ${err.message}`));
+      });
+
+      this.process.on("exit", (code, signal) => {
+        this.processExited = true;
+        this.exitCode = code;
+
+        const stderrTail = this.serverStderrLines.slice(-20).join("\n");
+        const msg = `MCP server exited with code ${code}${signal ? `, signal ${signal}` : ""}.\nServer output:\n${stderrTail}`;
+
+        for (const [id, { reject: rej }] of this.pendingRequests) {
+          rej(new Error(msg));
+        }
+        this.pendingRequests.clear();
+
+        if (!this.initialized) {
+          reject(new Error(msg));
+        }
+      });
+
+      const rl = readline.createInterface({
+        input: this.process.stdout,
+        crlfDelay: Infinity,
+      });
+
+      rl.on("line", (line) => {
+        try {
+          const message = JSON.parse(line);
+          this.handleMessage(message);
+        } catch (e) {
+          console.error("[MCP Server]", line);
+        }
+      });
+
+      this.process.stderr.on("data", (data) => {
+        const text = data.toString().trimEnd();
+        this.serverStderrLines.push(text);
+        console.error("[MCP Server]", text);
+      });
+
+      setTimeout(() => {
+        if (this.process && !this.process.killed && !this.processExited) {
+          resolve();
+        }
+      }, 500);
+    });
+  }
+
+  handleMessage(message) {
+    if (message.id !== undefined && this.pendingRequests.has(message.id)) {
+      const { resolve, reject } = this.pendingRequests.get(message.id);
+      this.pendingRequests.delete(message.id);
+
+      if (message.error) {
+        reject(
+          new Error(message.error.message || JSON.stringify(message.error)),
+        );
+      } else {
+        resolve(message.result);
+      }
+    }
+  }
+
+  sendRequest(method, params = {}) {
+    return new Promise((resolve, reject) => {
+      const id = ++this.messageId;
+      const request = {
+        jsonrpc: "2.0",
+        id,
+        method,
+        params,
+      };
+
+      this.pendingRequests.set(id, { resolve, reject });
+      this.process.stdin.write(JSON.stringify(request) + "\n");
+    });
+  }
+
+  sendNotification(method, params = {}) {
+    const notification = {
+      jsonrpc: "2.0",
+      method,
+      params,
+    };
+    this.process.stdin.write(JSON.stringify(notification) + "\n");
+  }
+
+  async initialize() {
+    const result = await Promise.race([
+      this.sendRequest("initialize", {
+        protocolVersion: MCP_PROTOCOL_VERSION,
+        capabilities: {},
+        clientInfo: {
+          name: "quartermaster-code-runner",
+          version: "1.0.0",
+        },
+      }),
+      new Promise((_, reject) =>
+        setTimeout(
+          () => reject(new Error("Initialize timeout")),
+          INITIALIZE_TIMEOUT,
+        ),
+      ),
+    ]);
+
+    // Send initialized notification
+    this.sendNotification("notifications/initialized");
+    this.initialized = true;
+
+    return result;
+  }
+
+  async listTools() {
+    const result = await this.sendRequest("tools/list", {});
+    return result.tools || [];
+  }
+
+  async callTool(name, arguments_) {
+    const result = await Promise.race([
+      this.sendRequest("tools/call", {
+        name,
+        arguments: arguments_,
+      }),
+      new Promise((_, reject) =>
+        setTimeout(
+          () => reject(new Error("Tool call timeout")),
+          TOOL_CALL_TIMEOUT,
+        ),
+      ),
+    ]);
+
+    // Parse content from result
+    const content = result.content || [];
+    const textParts = [];
+
+    for (const item of content) {
+      if (item.type === "text") {
+        textParts.push(item.text || "");
+      } else if (item.type === "image") {
+        textParts.push(`[Image: ${item.mimeType || "unknown"}]`);
+      } else if (item.type === "resource") {
+        textParts.push(`[Resource: ${item.uri || "unknown"}]`);
+      }
+    }
+
+    return textParts.join("\n");
+  }
+
+  async close() {
+    if (this.process && !this.process.killed) {
+      this.process.kill();
+    }
+  }
+}
+
+async function main() {
+  const command = process.env.MCP_COMMAND;
+  const operation = process.env.MCP_OPERATION || "call_tool";
+  const toolName = process.env.MCP_TOOL_NAME;
+  const toolArgumentsJson = process.env.MCP_TOOL_ARGUMENTS || "{}";
+
+  if (!command) {
+    console.error("Error: MCP_COMMAND environment variable is required");
+    process.exit(1);
+  }
+
+  if (operation === "call_tool" && !toolName) {
+    console.error(
+      "Error: MCP_TOOL_NAME environment variable is required for call_tool operation",
+    );
+    process.exit(1);
+  }
+
+  let toolArguments;
+  try {
+    toolArguments = JSON.parse(toolArgumentsJson);
+  } catch (e) {
+    console.error("Error: MCP_TOOL_ARGUMENTS must be valid JSON");
+    process.exit(1);
+  }
+
+  // Extract MCP_ENV_* variables for the server
+  const serverEnv = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (key.startsWith("MCP_ENV_")) {
+      serverEnv[key.substring(8)] = value;
+    }
+  }
+
+  const client = new McpStdioClient(command, serverEnv);
+
+  try {
+    console.error(`Starting MCP server: ${command}`);
+    await client.start();
+
+    console.error("Initializing MCP connection...");
+    await client.initialize();
+
+    if (operation === "list_tools") {
+      console.error("Listing tools...");
+      const tools = await client.listTools();
+      console.log(JSON.stringify(tools));
+    } else {
+      console.error(`Calling tool: ${toolName}`);
+      const result = await client.callTool(toolName, toolArguments);
+      console.log(result);
+    }
+
+    await client.close();
+    process.exit(0);
+  } catch (error) {
+    console.error("MCP Error:", error.message);
+    if (client.serverStderrLines.length > 0) {
+      console.error("--- MCP Server stderr ---");
+      for (const line of client.serverStderrLines) {
+        console.error(line);
+      }
+      console.error("--- End server stderr ---");
+    }
+    await client.close();
+    process.exit(1);
+  }
+}
+
+main();

quartermaster_code_runner/runtime/node/sdk.js

@@ -0,0 +1,109 @@
+/**
+ * quartermaster-code-runner SDK for Node.js runtime.
+ */
+
+const fs = require('fs');
+
+const METADATA_FILE = '/metadata/.quartermaster_metadata.json';
+
+/**
+ * Set the result metadata to be returned to the backend.
+ * 
+ * This separates structured results from stdout/stderr logs.
+ * 
+ * @param {any} data - Any JSON-serializable data (object, array, string, number, etc.)
+ * 
+ * @example
+ * const { setMetadata } = require('./sdk');
+ * 
+ * const result = { status: 'success', count: 42 };
+ * setMetadata(result);
+ */
+function setMetadata(data) {
+    fs.writeFileSync(METADATA_FILE, JSON.stringify(data));
+}
+
+/**
+ * Get previously set metadata (useful for reading/modifying).
+ * 
+ * @returns {any} The previously set metadata, or null if not set.
+ */
+function getMetadata() {
+    if (!fs.existsSync(METADATA_FILE)) {
+        return null;
+    }
+    return JSON.parse(fs.readFileSync(METADATA_FILE, 'utf8'));
+}
+
+/**
+ * Load a file from the flow's environment.
+ * Only available during flow execution, not test runs.
+ *
+ * @param {string} filePath - Path to the file within the environment.
+ * @returns {Promise<string>} The file content as a string.
+ */
+function loadFile(filePath) {
+    return new Promise((resolve, reject) => {
+        const webdavUrl = process.env.QM_WEBDAV_URL;
+        if (!webdavUrl) {
+            return reject(new Error(
+                'loadFile() is only available during flow execution. ' +
+                'For test runs, use mounted environments instead.'
+            ));
+        }
+        const url = new URL(filePath.replace(/^\//, ''), webdavUrl.replace(/\/?$/, '/'));
+        const mod = url.protocol === 'https:' ? require('https') : require('http');
+        mod.get(url.href, (res) => {
+            if (res.statusCode === 404) {
+                return reject(new Error(`File not found: ${filePath}`));
+            }
+            if (res.statusCode < 200 || res.statusCode >= 300) {
+                return reject(new Error(`Failed to load file: HTTP ${res.statusCode}`));
+            }
+            const chunks = [];
+            res.on('data', (chunk) => chunks.push(chunk));
+            res.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+            res.on('error', reject);
+        }).on('error', reject);
+    });
+}
+
+/**
+ * Save a file to the flow's environment.
+ * Only available during flow execution, not test runs.
+ *
+ * @param {string} filePath - Path to the file within the environment.
+ * @param {string} content - The file content to save.
+ * @returns {Promise<void>}
+ */
+function saveFile(filePath, content) {
+    return new Promise((resolve, reject) => {
+        const webdavUrl = process.env.QM_WEBDAV_URL;
+        if (!webdavUrl) {
+            return reject(new Error(
+                'saveFile() is only available during flow execution. ' +
+                'For test runs, use mounted environments instead.'
+            ));
+        }
+        const url = new URL(filePath.replace(/^\//, ''), webdavUrl.replace(/\/?$/, '/'));
+        const mod = url.protocol === 'https:' ? require('https') : require('http');
+        const data = Buffer.from(content, 'utf8');
+        const options = {
+            method: 'PUT',
+            headers: {
+                'Content-Type': 'application/octet-stream',
+                'Content-Length': data.length,
+            },
+        };
+        const req = mod.request(url.href, options, (res) => {
+            if (res.statusCode < 200 || res.statusCode >= 300) {
+                return reject(new Error(`Failed to save file: HTTP ${res.statusCode}`));
+            }
+            resolve();
+        });
+        req.on('error', reject);
+        req.end(data);
+    });
+}
+
+module.exports = { setMetadata, getMetadata, loadFile, saveFile };

quartermaster_code_runner/runtime/python/Dockerfile

@@ -0,0 +1,42 @@
+FROM python:3.12-slim
+
+LABEL qm.name="Python"
+LABEL qm.description="Python 3.12 with uv/uvx package manager"
+LABEL qm.default_entrypoint="python main.py"
+LABEL qm.file_extension=".py"
+LABEL qm.main_file="main.py"
+
+WORKDIR /app
+
+RUN apt-get update && \
+    apt-get install -y tar curl git && \
+    rm -rf /var/lib/apt/lists/* && \
+    useradd --uid 1001 --no-create-home --shell /bin/sh runner
+
+# Install uv package manager for uvx support
+RUN curl -LsSf https://astral.sh/uv/install.sh | sh && \
+    cp /root/.local/bin/uv /usr/local/bin/uv && \
+    cp /root/.local/bin/uvx /usr/local/bin/uvx && \
+    chmod 755 /usr/local/bin/uv /usr/local/bin/uvx
+
+# Make uv tool bin dir available to all users
+ENV PATH="/root/.local/bin:$PATH"
+
+# Pre-install common Python packages
+RUN pip install --no-cache-dir \
+    pandas \
+    numpy \
+    requests \
+    httpx \
+    beautifulsoup4 \
+    openpyxl \
+    google-auth \
+    google-auth-oauthlib \
+    google-api-python-client
+
+COPY entrypoint.sh .
+COPY sdk.py .
+COPY mcp-client.py .
+RUN chmod +x entrypoint.sh
+
+ENTRYPOINT ["/app/entrypoint.sh"]

quartermaster_code_runner/runtime/python/completions.json

@@ -0,0 +1,34 @@
+[
+    {
+        "caption": "from sdk import set_metadata",
+        "value": "from sdk import set_metadata",
+        "meta": "import",
+        "score": 1000
+    },
+    {
+        "caption": "from sdk import get_metadata",
+        "value": "from sdk import get_metadata",
+        "meta": "import",
+        "score": 1000
+    },
+    {
+        "caption": "from sdk import set_metadata, get_metadata",
+        "value": "from sdk import set_metadata, get_metadata",
+        "meta": "import",
+        "score": 1000
+    },
+    {
+        "caption": "set_metadata",
+        "snippet": "set_metadata($1)",
+        "meta": "sdk",
+        "score": 1000,
+        "docText": "Set structured result metadata to be returned to the backend. Accepts any JSON-serializable data."
+    },
+    {
+        "caption": "get_metadata",
+        "snippet": "get_metadata()",
+        "meta": "sdk",
+        "score": 1000,
+        "docText": "Get previously set metadata. Returns None if not set."
+    }
+]

quartermaster_code_runner/runtime/python/entrypoint.sh

@@ -0,0 +1,30 @@
+#!/bin/sh
+set -e
+
+chown runner:runner /tmp
+chown runner:runner /metadata 2>/dev/null || true
+
+exec su -p -s /bin/sh -c '
+    set -e
+    cd /tmp
+
+    # Copy SDK for user code access
+    cp /app/sdk.py /tmp/sdk.py
+
+    # Decode code to default filename
+    if [ -n "$ENCODED_CODE" ]; then
+        echo "$ENCODED_CODE" | base64 -d > main.py
+    fi
+
+    # Extract additional files if provided
+    if [ -n "$ENCODED_FILES" ]; then
+        echo "$ENCODED_FILES" | base64 -d | tar -xz
+    fi
+
+    # Execute custom entrypoint or default
+    if [ -n "$CUSTOM_ENTRYPOINT" ]; then
+        exec sh -c "$CUSTOM_ENTRYPOINT"
+    else
+        exec python main.py
+    fi
+' runner