@sanlabs/sanbox-cli 0.0.1 → 0.0.3

package/dist/config.js

@@ -1,12 +1,60 @@
-export const defaultApiUrl = "http://127.0.0.1:8788";
-export const defaultWorkloadId = "opencode-runner";
+import fs from "node:fs";
+import path from "node:path";
+import { CliError, commandAction } from "./errors.js";
+export const defaultApiUrl = "https://console.sanbox.cloud";
+export const readLocalConfig = (cwd = process.cwd()) => {
+    const configPath = path.join(cwd, ".sanbox", "config.json");
+    try {
+        const parsed = JSON.parse(fs.readFileSync(configPath, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return {};
+        const record = parsed;
+        return {
+            api_url: typeof record.api_url === "string" ? record.api_url : undefined,
+            org: typeof record.org === "string" ? record.org : undefined,
+            default_template: typeof record.default_template === "string" ? record.default_template : undefined
+        };
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return {};
+        throw error;
+    }
+};
 export const readConfig = (flags = {}) => {
-    const apiUrl = String(flags["api-url"] || process.env.SANBOX_API_URL || defaultApiUrl).replace(/\/+$/, "");
-    const org = String(flags.org || process.env.SANBOX_ORG || "").trim();
+    const localConfig = readLocalConfig();
+    const apiUrl = String(flags["api-url"] || process.env.SANBOX_API_URL || localConfig.api_url || defaultApiUrl).replace(/\/+$/, "");
+    const org = String(flags.org || process.env.SANBOX_ORG || localConfig.org || "").trim();
     const apiKey = process.env.SANBOX_API_KEY || "";
-    if (!org)
-        throw new Error("SANBOX_ORG or --org is required.");
-    if (!apiKey)
-        throw new Error("SANBOX_API_KEY is required.");
+    if (!org) {
+        throw new CliError("org_required", "Organization context is required.", {
+            nextActions: [commandAction(["sanbox", "context", "--json"], "Select an organization and retry with SANBOX_ORG set.", { SANBOX_ORG: "<org-slug>" })]
+        });
+    }
+    if (!apiKey) {
+        throw new CliError("api_key_required", "SANBOX_API_KEY is required.", {
+            nextActions: [commandAction(["sanbox", "auth", "check", "--json"], "Set a Sanbox control-plane API key and check access.", { SANBOX_API_KEY: "<sanbox-api-key>" })]
+        });
+    }
     return { apiUrl, org, apiKey };
 };
+export function readTemplateSelection(flags = {}, options = {}) {
+    const flagValue = flags.template;
+    if (typeof flagValue === "string" && flagValue.trim())
+        return { id: flagValue.trim(), source: "flag" };
+    const envValue = process.env.SANBOX_TEMPLATE?.trim();
+    if (envValue)
+        return { id: envValue, source: "environment" };
+    const configValue = readLocalConfig(options.cwd).default_template?.trim();
+    if (configValue)
+        return { id: configValue, source: "project_config" };
+    if (options.required === false)
+        return null;
+    throw new CliError("template_required", "A template must be selected explicitly.", {
+        nextActions: [
+            commandAction(["sanbox", "templates", "list", "--json"], "List templates available to the selected organization."),
+            commandAction(["sanbox", "run", "<task>", "--template", "<template-id>"], "Run with an explicit template."),
+            commandAction(["sanbox", "context", "--json"], "Select a template for this shell and inspect the resolved context.", { SANBOX_TEMPLATE: "<template-id>" })
+        ]
+    });
+}

package/dist/dossier.js

@@ -1,6 +1,7 @@
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
+import { inflateRawSync } from "node:zlib";
 import fg from "fast-glob";
 import ignore from "ignore";
 import yazl from "yazl";
@@ -34,7 +35,28 @@ const defaultIgnorePatterns = [
     "**/id_rsa",
     "**/id_ed25519"
 ];
-const normalizeInclude = (patterns) => patterns.length === 0 ? ["**/*"] : patterns.map((pattern) => (pattern === "." ? "**/*" : pattern));
+const normalizePattern = async (cwd, pattern) => {
+    if (pattern === ".")
+        return "**/*";
+    const normalized = pattern.replaceAll(path.sep, "/").replace(/\/+$/, "");
+    if (normalized.includes("*"))
+        return normalized;
+    try {
+        const stat = await fs.stat(path.resolve(cwd, normalized));
+        if (stat.isDirectory())
+            return `${normalized}/**`;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    return normalized;
+};
+const normalizeInclude = async (cwd, patterns) => {
+    if (patterns.length === 0)
+        return ["**/*"];
+    return Promise.all(patterns.map((pattern) => normalizePattern(cwd, pattern)));
+};
 const readSanboxIgnore = async (cwd) => {
     try {
         const raw = await fs.readFile(path.join(cwd, ".sanboxignore"), "utf8");
@@ -54,11 +76,11 @@ const zipToBuffer = async (zip) => new Promise((resolve, reject) => {
     zip.end();
 });
 export const sha256 = (buffer) => crypto.createHash("sha256").update(buffer).digest("hex");
-export const buildTaskDossier = async (input) => {
-    const patterns = normalizeInclude(input.include);
-    const ig = ignore().add([...defaultIgnorePatterns, ...(await readSanboxIgnore(input.cwd))]);
+const selectedFiles = async (cwd, include) => {
+    const patterns = await normalizeInclude(cwd, include);
+    const ig = ignore().add([...defaultIgnorePatterns, ...(await readSanboxIgnore(cwd))]);
     const candidates = await fg(patterns, {
-        cwd: input.cwd,
+        cwd,
         dot: true,
         onlyFiles: true,
         followSymbolicLinks: false,
@@ -69,6 +91,23 @@ export const buildTaskDossier = async (input) => {
         .filter((item) => !item.startsWith("../") && !path.isAbsolute(item))
         .filter((item) => !ig.ignores(item))
         .sort();
+    return { patterns, files };
+};
+export const previewTaskDossier = async (input) => {
+    const { patterns, files } = await selectedFiles(input.cwd, input.include);
+    const previewFiles = [];
+    let totalBytes = 0;
+    for (const rel of files) {
+        const stat = await fs.stat(path.join(input.cwd, rel));
+        if (!stat.isFile())
+            continue;
+        totalBytes += stat.size;
+        previewFiles.push({ path: rel, size: stat.size });
+    }
+    return { patterns, files: previewFiles, totalBytes };
+};
+export const buildTaskDossier = async (input) => {
+    const { files } = await selectedFiles(input.cwd, input.include);
     const zip = new yazl.ZipFile();
     const fileMetadata = [];
     const runbook = [
@@ -106,3 +145,43 @@ export const readDossierFile = async (dossierPath) => {
     const buffer = await fs.readFile(dossierPath);
     return { buffer, sha256: sha256(buffer), files: [] };
 };
+export const writeTaskDossier = async (input) => {
+    const dossier = await buildTaskDossier(input);
+    await fs.mkdir(path.dirname(input.outPath), { recursive: true });
+    await fs.writeFile(input.outPath, dossier.buffer);
+    return dossier;
+};
+const readUInt16 = (buffer, offset) => buffer.readUInt16LE(offset);
+const readUInt32 = (buffer, offset) => buffer.readUInt32LE(offset);
+export const inspectDossierFile = async (dossierPath) => {
+    const buffer = await fs.readFile(dossierPath);
+    const entries = [];
+    let runbook;
+    let manifest;
+    let offset = 0;
+    while (offset + 30 <= buffer.length && readUInt32(buffer, offset) === 0x04034b50) {
+        const compressionMethod = readUInt16(buffer, offset + 8);
+        const compressedSize = readUInt32(buffer, offset + 18);
+        const uncompressedSize = readUInt32(buffer, offset + 22);
+        const nameLength = readUInt16(buffer, offset + 26);
+        const extraLength = readUInt16(buffer, offset + 28);
+        const nameStart = offset + 30;
+        const dataStart = nameStart + nameLength + extraLength;
+        const dataEnd = dataStart + compressedSize;
+        if (dataEnd > buffer.length)
+            break;
+        const entryPath = buffer.subarray(nameStart, nameStart + nameLength).toString("utf8");
+        entries.push({ path: entryPath, compressedSize, uncompressedSize });
+        if (entryPath === "RUNBOOK.md" || entryPath === "manifest.json") {
+            const compressed = buffer.subarray(dataStart, dataEnd);
+            const content = compressionMethod === 0 ? compressed : inflateRawSync(compressed);
+            const text = content.toString("utf8");
+            if (entryPath === "RUNBOOK.md")
+                runbook = text;
+            if (entryPath === "manifest.json")
+                manifest = JSON.parse(text);
+        }
+        offset = dataEnd;
+    }
+    return { entries, runbook, manifest };
+};

package/dist/errors.js

@@ -0,0 +1,24 @@
+export class CliError extends Error {
+    code;
+    options;
+    constructor(code, message, options = {}) {
+        super(message);
+        this.code = code;
+        this.options = options;
+        this.name = "CliError";
+    }
+    get exitCode() {
+        return this.options.exitCode ?? 1;
+    }
+}
+export const commandAction = (argv, description, env) => ({
+    type: "command",
+    argv,
+    ...(env ? { env } : {}),
+    description
+});
+export const consoleAction = (url, description) => ({
+    type: "console",
+    url,
+    description
+});

package/dist/output.js

@@ -1,9 +1,85 @@
+import { CliError } from "./errors.js";
+import { SanboxApiError } from "./api.js";
 export const printJson = (value) => {
     process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
 };
+export const successEnvelope = (command, data, context = {}, nextActions = []) => ({
+    schema_version: 1,
+    ok: true,
+    command,
+    context,
+    data,
+    next_actions: nextActions
+});
+export const errorEnvelope = (command, error, context = {}) => {
+    if (error instanceof CliError) {
+        return {
+            schema_version: 1,
+            ok: false,
+            command,
+            context,
+            error: {
+                code: error.code,
+                message: error.message,
+                ...(error.options.status === undefined ? {} : { status: error.options.status }),
+                ...(error.options.details === undefined ? {} : { details: error.options.details })
+            },
+            next_actions: error.options.nextActions ?? []
+        };
+    }
+    if (error instanceof SanboxApiError) {
+        return {
+            schema_version: 1,
+            ok: false,
+            command,
+            context,
+            error: {
+                code: error.code,
+                message: error.message,
+                status: error.status
+            },
+            next_actions: []
+        };
+    }
+    return {
+        schema_version: 1,
+        ok: false,
+        command,
+        context,
+        error: {
+            code: "cli_error",
+            message: error instanceof Error ? error.message : String(error)
+        },
+        next_actions: []
+    };
+};
+export const printSuccess = (command, data, context = {}, nextActions = []) => printJson(successEnvelope(command, data, context, nextActions));
+export const printError = (command, error, context = {}) => {
+    process.stderr.write(`${JSON.stringify(errorEnvelope(command, error, context), null, 2)}\n`);
+};
+export const printJsonlError = (command, error, context = {}) => {
+    process.stderr.write(`${JSON.stringify(errorEnvelope(command, error, context))}\n`);
+};
+export const publicRun = (run) => {
+    const { workload_id: workloadId, ...rest } = run;
+    return {
+        ...rest,
+        template_id: run.template_id || workloadId || null
+    };
+};
+export const publicRunPayload = (payload) => ({
+    run: publicRun(payload.run),
+    events: payload.events
+});
 export const summarizeRun = (payload) => {
     const { run } = payload;
-    return `${run.id} ${run.status}${run.exit_code === null ? "" : ` exit=${run.exit_code}`}${run.error ? ` error=${run.error}` : ""}`;
+    const templateId = run.template_id || run.workload_id;
+    const selection = [
+        templateId ? `template=${templateId}` : "",
+        run.provider_id ? `provider=${run.provider_id}` : "",
+        run.model_id ? `model=${run.model_id}` : ""
+    ].filter(Boolean).join(" ");
+    return `${run.id} ${run.status}${selection ? ` ${selection}` : ""}${run.exit_code === null ? "" : ` exit=${run.exit_code}`}${run.error ? ` error=${run.error}` : ""}`;
 };
 export const printRun = (payload) => {
     process.stdout.write(`${summarizeRun(payload)}\n`);

package/dist/runs.js

@@ -1,7 +1,6 @@
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { defaultWorkloadId } from "./config.js";
 import { buildTaskDossier, readDossierFile } from "./dossier.js";
 const terminalStatuses = new Set(["completed", "failed", "canceled", "expired"]);
 const inlineLimitBytes = 8 * 1024 * 1024;
@@ -42,7 +41,7 @@ export const createRun = async (client, options) => {
     };
     return client.createRun({
         external_run_id: options.externalRunId,
-        workload_id: options.workloadId || defaultWorkloadId,
+        workload_id: options.templateId,
         manifest,
         retention_ttl_seconds: options.retentionTtlSeconds
     });

package/dist/version.js

@@ -1 +1 @@
-export const version = "0.0.1";
+export const version = "0.0.3";

package/dist/watch.js

@@ -0,0 +1,111 @@
+import { SanboxApiError } from "./api.js";
+const terminalStatuses = new Set(["completed", "failed", "canceled", "expired"]);
+const terminalEventKinds = new Set(["run.completed", "run.failed", "run.canceled", "run.expired"]);
+const retryableNetworkCodes = new Set(["ECONNRESET", "ECONNREFUSED", "EPIPE", "ETIMEDOUT", "EAI_AGAIN", "ENETUNREACH"]);
+export class WatchInterruptedError extends Error {
+    constructor() {
+        super("Watch interrupted.");
+        this.name = "WatchInterruptedError";
+    }
+}
+const defaultSleep = (milliseconds, signal) => new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+        reject(new WatchInterruptedError());
+        return;
+    }
+    const timer = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve();
+    }, milliseconds);
+    const onAbort = () => {
+        clearTimeout(timer);
+        reject(new WatchInterruptedError());
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+});
+const isRetryable = (error) => {
+    if (error instanceof SanboxApiError)
+        return error.status === 429 || error.status >= 500;
+    if (error instanceof TypeError)
+        return true;
+    const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
+    return retryableNetworkCodes.has(code);
+};
+const assertActive = (signal, deadline, now, runId) => {
+    if (signal?.aborted)
+        throw new WatchInterruptedError();
+    if (now() >= deadline)
+        throw new Error(`Timed out watching run ${runId}.`);
+};
+export const isTerminalStatus = (status) => terminalStatuses.has(status);
+export const watchRun = async (client, runId, options) => {
+    const pageSize = Math.max(1, Math.min(500, Math.floor(options.pageSize ?? 200)));
+    const pollIntervalMs = Math.max(1, Math.floor(options.pollIntervalMs ?? 2000));
+    const terminalDrainIntervalMs = Math.max(1, Math.floor(options.terminalDrainIntervalMs ?? Math.min(250, pollIntervalMs)));
+    const timeoutSeconds = Math.max(1, options.timeoutSeconds ?? 1800);
+    const maxReconnectDelayMs = Math.max(250, options.maxReconnectDelayMs ?? 10_000);
+    const sleep = options.sleep ?? defaultSleep;
+    const now = options.now ?? Date.now;
+    const random = options.random ?? Math.random;
+    const deadline = now() + timeoutSeconds * 1000;
+    let cursor = Math.max(0, Math.floor(options.afterEventId ?? 0));
+    let sawTerminalEvent = false;
+    let emptyTerminalReads = 0;
+    const request = async (operation) => {
+        let attempt = 0;
+        for (;;) {
+            assertActive(options.signal, deadline, now, runId);
+            try {
+                return await operation();
+            }
+            catch (error) {
+                if (options.signal?.aborted)
+                    throw new WatchInterruptedError();
+                if (error instanceof WatchInterruptedError || !isRetryable(error))
+                    throw error;
+                attempt += 1;
+                const exponential = Math.min(maxReconnectDelayMs, 250 * (2 ** Math.min(attempt - 1, 8)));
+                const remainingMs = deadline - now();
+                if (remainingMs <= 0)
+                    throw new Error(`Timed out watching run ${runId}.`);
+                const delayMs = Math.min(remainingMs, Math.max(1, Math.floor(exponential * (0.8 + random() * 0.4))));
+                options.onRetry?.({ error, attempt, delayMs });
+                await sleep(delayMs, options.signal);
+            }
+        }
+    };
+    for (;;) {
+        assertActive(options.signal, deadline, now, runId);
+        let deliveredThisCycle = 0;
+        let fetchAnotherPage = true;
+        while (fetchAnotherPage) {
+            const page = await request(() => client.listEvents(runId, cursor, pageSize, options.signal));
+            const previousCursor = cursor;
+            const ordered = [...page.events].sort((left, right) => left.id - right.id);
+            const seen = new Set();
+            for (const event of ordered) {
+                if (!Number.isSafeInteger(event.id) || event.id <= cursor || seen.has(event.id))
+                    continue;
+                seen.add(event.id);
+                await options.onEvent(event);
+                cursor = event.id;
+                deliveredThisCycle += 1;
+                if (terminalEventKinds.has(event.kind))
+                    sawTerminalEvent = true;
+            }
+            const reportedMore = page.has_more ?? page.events.length >= pageSize;
+            fetchAnotherPage = reportedMore && cursor > previousCursor;
+        }
+        const payload = await request(() => client.getRun(runId, options.signal));
+        if (isTerminalStatus(payload.run.status)) {
+            emptyTerminalReads = deliveredThisCycle === 0 ? emptyTerminalReads + 1 : 0;
+            const requiredEmptyReads = sawTerminalEvent ? 1 : 2;
+            if (emptyTerminalReads >= requiredEmptyReads)
+                return payload;
+            await sleep(terminalDrainIntervalMs, options.signal);
+            continue;
+        }
+        emptyTerminalReads = 0;
+        await sleep(pollIntervalMs, options.signal);
+    }
+};

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "@sanlabs/sanbox-cli",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "private": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sanlabs-ai/sanbox.git",
+    "directory": "cli"
+  },
   "type": "module",
   "bin": {
-    "sanbox": "dist/cli.js",
-    "sanbox-mcp": "dist/mcp.js"
+    "sanbox": "dist/cli.js"
   },
   "files": [
     "dist",
@@ -19,14 +23,13 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "test": "tsx --test test/**/*.test.ts",
     "dev": "tsx src/cli.ts"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.21.0",
     "fast-glob": "^3.3.3",
     "ignore": "^7.0.5",
-    "yazl": "^3.3.1",
-    "zod": "^3.25.76"
+    "yazl": "^3.3.1"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",

package/dist/mcp.js

@@ -1,131 +0,0 @@
-#!/usr/bin/env node
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import * as z from "zod/v4";
-import { SanboxClient } from "./api.js";
-import { defaultWorkloadId, readConfig } from "./config.js";
-import { createRun, readTasks, runPool, stableBatchId, waitForRun } from "./runs.js";
-import { version } from "./version.js";
-const textAndJson = (summary, structuredContent) => ({
-    content: [{ type: "text", text: `${summary}\n\n${JSON.stringify(structuredContent, null, 2)}` }],
-    structuredContent
-});
-const client = () => new SanboxClient(readConfig());
-const server = new McpServer({
-    name: "sanbox",
-    version
-});
-server.registerTool("create_sandbox_run", {
-    title: "Create Sanbox Run",
-    description: "Create one Sanbox run from a task or existing dossier ZIP.",
-    inputSchema: {
-        task: z.string().optional().describe("Task instructions. Required unless dossier_path is provided."),
-        dossier_path: z.string().optional().describe("Path to an existing dossier ZIP."),
-        include: z.array(z.string()).optional().describe("Repo file globs to include when task is provided."),
-        external_run_id: z.string().optional().describe("Optional idempotency key."),
-        workload_id: z.string().optional().default(defaultWorkloadId),
-        wait: z.boolean().optional().default(false)
-    }
-}, async (args) => {
-    if (!args.task && !args.dossier_path)
-        throw new Error("task or dossier_path is required.");
-    const api = client();
-    let payload = await createRun(api, {
-        cwd: process.cwd(),
-        cliVersion: version,
-        task: args.task,
-        dossierPath: args.dossier_path,
-        include: args.include || [],
-        externalRunId: args.external_run_id,
-        workloadId: args.workload_id || defaultWorkloadId
-    });
-    if (args.wait)
-        payload = await waitForRun(api, payload.run.id);
-    return textAndJson(`Run ${payload.run.id} is ${payload.run.status}.`, payload);
-});
-server.registerTool("create_sandbox_runs", {
-    title: "Create Multiple Sanbox Runs",
-    description: "Create independent Sanbox runs for parallel task delegation.",
-    inputSchema: {
-        tasks: z.array(z.object({
-            task: z.string(),
-            external_run_id: z.string().optional(),
-            include: z.array(z.string()).optional()
-        })).optional().describe("Inline tasks to run."),
-        tasks_path: z.string().optional().describe("Path to a JSON task array."),
-        include: z.array(z.string()).optional().describe("Default repo file globs for generated dossiers."),
-        batch_id: z.string().optional().describe("Optional stable batch id for idempotency."),
-        max_parallel: z.number().int().min(1).max(20).optional().default(5),
-        wait: z.boolean().optional().default(false)
-    }
-}, async (args) => {
-    const tasks = args.tasks_path ? await readTasks(args.tasks_path) : args.tasks;
-    if (!tasks || tasks.length === 0)
-        throw new Error("tasks or tasks_path is required.");
-    const batchId = args.batch_id || (args.tasks_path ? await stableBatchId(args.tasks_path) : `mcp-${Date.now().toString(36)}`);
-    const api = client();
-    const results = await runPool(tasks, args.max_parallel || 5, async (task, index) => {
-        let payload = await createRun(api, {
-            cwd: process.cwd(),
-            cliVersion: version,
-            task: task.task,
-            include: task.include || args.include || [],
-            externalRunId: task.external_run_id || `sanbox-batch-${batchId}-${index + 1}`,
-            workloadId: defaultWorkloadId
-        });
-        if (args.wait)
-            payload = await waitForRun(api, payload.run.id);
-        return payload;
-    });
-    const structured = { batch_id: batchId, runs: results.map((result) => result.run), results };
-    return textAndJson(`Created ${results.length} Sanbox runs.`, structured);
-});
-server.registerTool("get_sandbox_run", {
-    title: "Get Sanbox Run",
-    description: "Fetch a Sanbox run and recent events.",
-    inputSchema: {
-        run_id: z.string()
-    }
-}, async ({ run_id }) => {
-    const payload = await client().getRun(run_id);
-    return textAndJson(`Run ${payload.run.id} is ${payload.run.status}.`, payload);
-});
-server.registerTool("list_sandbox_events", {
-    title: "List Sanbox Events",
-    description: "List events for a Sanbox run.",
-    inputSchema: {
-        run_id: z.string(),
-        after_event_id: z.number().int().min(0).optional().default(0)
-    }
-}, async ({ run_id, after_event_id }) => {
-    const payload = await client().listEvents(run_id, after_event_id || 0);
-    return textAndJson(`Found ${payload.events.length} events.`, payload);
-});
-server.registerTool("cancel_sandbox_run", {
-    title: "Cancel Sanbox Run",
-    description: "Request cancellation for a queued or running Sanbox run.",
-    inputSchema: {
-        run_id: z.string()
-    }
-}, async ({ run_id }) => {
-    const payload = await client().cancelRun(run_id);
-    return textAndJson(`Cancel requested for ${payload.run.id}.`, payload);
-});
-server.registerTool("send_sandbox_message", {
-    title: "Send Sanbox Message",
-    description: "Ask a follow-up question against a retained Sanbox run workspace.",
-    inputSchema: {
-        run_id: z.string(),
-        message: z.string()
-    }
-}, async ({ run_id, message }) => {
-    const payload = await client().sendMessage(run_id, message);
-    return textAndJson(`Message sent to ${payload.run.id}.`, payload);
-});
-const main = async () => {
-    await server.connect(new StdioServerTransport());
-};
-main().catch((error) => {
-    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-    process.exit(1);
-});