How to Send Input to a Running Command in a Sandbox

cat > msgs.jsonl <<'EOF'
{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"cli","version":"0"}}}
{"jsonrpc":"2.0","method":"notifications/initialized"}
{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"echo","arguments":{"message":"hello from my laptop"}}}
EOF
time sbx exec -i sb_tlgdxpd6dx -- mcp-server-everything stdio < msgs.jsonl 2>/dev/null

{"result":{"protocolVersion":"2025-06-18","capabilities":{"prompts":{"listChanged":true},…
{"result":{"content":[{"type":"text","text":"Echo: hello from my laptop"}]},"jsonrpc":"2.0","id":2}

real	0m0.326s

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

const transport = new StdioClientTransport({
  command: "sbx",
  args: ["exec", "-i", process.env.SANDBOX_ID, "--", "mcp-server-everything", "stdio"],
  env: process.env,          // passes SANDBOXER_API_KEY through to sbx
  stderr: "ignore",
});
const client = new Client({ name: "laptop", version: "1.0.0" });
const t0 = performance.now();
await client.connect(transport);
const v = client.getServerVersion();
console.log(`connected in ${Math.round(performance.now() - t0)} ms:`, v.name, v.version);
console.log("tools:", (await client.listTools()).tools.length);

const ms = [];
for (let i = 0; i < 10; i++) {
  const s = performance.now();
  const r = await client.callTool({ name: "echo", arguments: { message: `hi ${i}` } });
  ms.push(Math.round(performance.now() - s));
  if (i === 0) console.log(r.content[0].text);
}
console.log("echo round trips (ms):", ms.join(" "));
await client.close();

connected in 303 ms: mcp-servers/everything 2.0.1
tools: 16
Echo: hi 0
echo round trips (ms): 33 29 30 30 30 30 30 29 30 29

(sleep 600 | sbx exec -i sb_tlgdxpd6dx -- mcp-server-everything stdio >/dev/null 2>&1) &
sleep 4; sbx exec sb_tlgdxpd6dx "pgrep -af [m]cp-server-everything"
pkill -f "sbx exec -i sb_tlgdxpd6dx"
sleep 3; sbx exec sb_tlgdxpd6dx "pgrep -af [m]cp-server-everything || echo none running"

633 node /usr/bin/mcp-server-everything stdio
none running

import { Sandboxer } from "sandboxer-sdk";

const sandbox = new Sandboxer().sandbox(process.env.SANDBOX_ID);
const waiting = new Map();
let buf = "";
const session = await sandbox.pty({
  command: "mcp-server-everything stdio",
  pty: false,
  onData: (data, stream) => {
    if (stream !== "stdout") return;
    buf += Buffer.from(data).toString();
    for (let nl; (nl = buf.indexOf("\n")) >= 0; buf = buf.slice(nl + 1)) {
      const msg = JSON.parse(buf.slice(0, nl));
      waiting.get(msg.id)?.(msg);
      waiting.delete(msg.id);
    }
  },
});

let next = 1;
const rpc = (method, params = {}) => new Promise((resolve) => {
  const id = next++;
  waiting.set(id, resolve);
  session.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n");
});

const init = await rpc("initialize", { protocolVersion: "2025-06-18", capabilities: {}, clientInfo: { name: "raw", version: "0" } });
console.log("server:", init.result.serverInfo.name, init.result.serverInfo.version);
session.write('{"jsonrpc":"2.0","method":"notifications/initialized"}\n');

const ms = [];
for (let i = 0; i < 10; i++) {
  const s = performance.now();
  await rpc("ping");
  ms.push(Math.round(performance.now() - s));
}
console.log("ping round trips (ms):", ms.join(" "));
const r = await rpc("tools/call", { name: "echo", arguments: { message: "over the WebSocket" } });
console.log(r.result.content[0].text);
session.eof();                                   // close stdin; the server exits
console.log("exit:", (await session.wait()).exitCode);

server: mcp-servers/everything 2.0.1
ping round trips (ms): 30 30 30 30 30 29 29 30 30 29
Echo: over the WebSocket
exit: 0

import asyncio, json, os, time
import websockets

URL = f"wss://sandboxer.com/api/v1/sandboxes/{os.environ['SANDBOX_ID']}/exec/ws"

async def main():
    headers = {"Authorization": f"Bearer {os.environ['SANDBOXER_API_KEY']}"}
    async with websockets.connect(URL, additional_headers=headers) as ws:
        await ws.send(json.dumps({"command": "mcp-server-everything stdio", "pty": False}))
        buf = b""

        async def rpc(msg):
            nonlocal buf
            await ws.send(json.dumps(msg).encode() + b"\n")          # bytes = a binary frame = stdin
            while True:
                frame = await ws.recv()
                if isinstance(frame, bytes) and frame[:1] == b"\x01":  # 1 = stdout
                    buf += frame[1:]
                    while b"\n" in buf:
                        line, buf = buf.split(b"\n", 1)
                        reply = json.loads(line)
                        if reply.get("id") == msg["id"]:
                            return reply

        init = await rpc({"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {
            "protocolVersion": "2025-06-18", "capabilities": {}, "clientInfo": {"name": "py", "version": "0"}}})
        print("server:", init["result"]["serverInfo"]["name"])
        await ws.send(b'{"jsonrpc":"2.0","method":"notifications/initialized"}\n')
        ms = []
        for i in range(10):
            t = time.perf_counter()
            await rpc({"jsonrpc": "2.0", "id": 100 + i, "method": "ping"})
            ms.append(round((time.perf_counter() - t) * 1000))
        print("ping round trips (ms):", *ms)
        await ws.send(json.dumps({"type": "eof"}))                   # str = a text frame = control
        async for frame in ws:
            if isinstance(frame, str):
                print(frame)

asyncio.run(main())

server: mcp-servers/everything
ping round trips (ms): 30 29 29 29 30 30 30 30 30 29
{"type":"exit","exitCode":0}

let out = "";
const term = await sandbox.pty({ command: "python3 -q", cols: 100, rows: 30, onData: (d) => { out += Buffer.from(d).toString(); } });
const until = async (text) => { while (!out.includes(text)) await new Promise((r) => setTimeout(r, 20)); };

await until(">>> ");
term.write("2 ** 100\n");
await until("1267650600228229401496703205376");
term.write("exit()\n");
console.log("exit:", (await term.wait()).exitCode);
console.log(JSON.stringify(out));

exit: 0
">>> 2 ** 100\r\n1267650600228229401496703205376\r\n>>> exit()\r\n"