mcp-agents 0.3.6 → 0.5.0

package/README.md

@@ -24,6 +24,7 @@ npx mcp-agents
 # Specific provider
 npx mcp-agents --provider claude
 npx mcp-agents --provider gemini
+npx mcp-agents --provider gemini --sandbox false
 ```
 
 The server speaks [JSON-RPC over stdio](https://modelcontextprotocol.io/docs/concepts/transports#stdio). It prints `[mcp-agents] ready (provider: <name>)` to stderr when it's listening.
@@ -50,7 +51,7 @@ Each `--provider` flag maps to a single exposed tool:
 | Parameter | Type | Required | Description |
 |-----------|------|----------|-------------|
 | `prompt` | `string` | yes | The prompt to send to Gemini CLI |
-| `sandbox` | `boolean` | no | Run in sandbox mode (`-s` flag) |
+| `sandbox` | `boolean` | no | Run in sandbox mode (`-s` flag, default: false) |
 | `timeout_ms` | `integer` | no | Timeout in ms (default: 120 000) |
 
 ### `codex` (pass-through)
@@ -78,7 +79,7 @@ Add entries to your project's `.mcp.json`:
     },
     "gemini": {
       "command": "npx",
-      "args": ["-y", "mcp-agents@latest", "--provider", "gemini"]
+      "args": ["-y", "mcp-agents@latest", "--provider", "gemini", "--sandbox", "false"]
     }
   }
 }
@@ -108,7 +109,7 @@ args = ["-y", "mcp-agents", "--provider", "claude"]
 
 [mcp_servers.gemini]
 command = "npx"
-args = ["-y", "mcp-agents", "--provider", "gemini"]
+args = ["-y", "mcp-agents", "--provider", "gemini", "--sandbox", "false"]
 ```
 
 Then in a Codex session you can call the `claude_code` or `gemini` tools, which shell out to the respective CLIs.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-agents",
-  "version": "0.3.6",
+  "version": "0.5.0",
   "description": "MCP server that wraps AI CLI tools (Claude Code, Gemini CLI, Codex CLI) for use by any MCP client",
   "type": "module",
   "bin": {

package/server.js

@@ -29,25 +29,27 @@ const CLI_BACKENDS = {
   claude: {
     command: "claude",
     toolName: "claude_code",
-    description: "Run Claude Code CLI (claude -p) with a prompt.",
-    buildArgs: (prompt) => ["--no-session-persistence", "-p", prompt],
+    description: "Run Claude Code CLI with a prompt (via stdin).",
+    stdinPrompt: true,
+    buildArgs: () => ["--no-session-persistence", "-p"],
     extraProperties: {},
   },
   gemini: {
     command: "gemini",
     toolName: "gemini",
     description: "Run Gemini CLI (gemini -p) with a prompt.",
+    stdinPrompt: false,
     buildArgs: (prompt, opts) => {
       const args = [];
-      if (opts.sandbox !== false) args.push("-s");
+      if (opts.sandbox === true) args.push("-s");
       args.push("-p", prompt);
       return args;
     },
     extraProperties: {
       sandbox: {
         type: "boolean",
-        default: true,
-        description: "Run in sandbox mode (-s flag). Defaults to true.",
+        default: false,
+        description: "Run in sandbox mode (-s flag). Defaults to false.",
       },
     },
   },
@@ -92,20 +94,22 @@ Options:
   --provider <name>              CLI backend to use (${providers}) [default: codex]
   --model <model>                Model to use (codex) [default: gpt-5.3-codex]
   --model_reasoning_effort <e>   Reasoning effort (codex) [default: high]
+  --sandbox <bool>               Gemini sandbox mode (true/false) [default: false]
   --help, -h                     Show this help message
   --version, -v                  Show version number`);
 }
 
 /**
  * Parse CLI flags from process.argv.
- * Handles --help, --version, --provider, --model, --model_reasoning_effort, and unknown flags.
- * @returns {{ provider: string, model?: string, modelReasoningEffort?: string }}
+ * Handles --help, --version, --provider, --model, --model_reasoning_effort, --sandbox, and unknown flags.
+ * @returns {{ provider: string, model?: string, modelReasoningEffort?: string, sandbox: boolean }}
  */
 function parseArgs() {
   const args = process.argv.slice(2);
   let provider = "codex";
   let model;
   let modelReasoningEffort;
+  let sandbox = false;
 
   for (let i = 0; i < args.length; i++) {
     switch (args[i]) {
@@ -142,24 +146,32 @@ function parseArgs() {
         }
         modelReasoningEffort = args[++i];
         break;
+      case "--sandbox":
+        if (i + 1 >= args.length) {
+          process.stderr.write("error: --sandbox requires a value\n");
+          process.exit(1);
+        }
+        sandbox = args[++i] === "true";
+        break;
       default:
         process.stderr.write(`error: unknown option: ${args[i]}\n`);
         process.exit(1);
     }
   }
 
-  return { provider, model, modelReasoningEffort };
+  return { provider, model, modelReasoningEffort, sandbox };
 }
 
 /**
  * Run a CLI command and return stdout (or stderr if stdout is empty).
  * @param {string} command
  * @param {string[]} args
- * @param {{ timeoutMs?: number }} [opts]
+ * @param {{ timeoutMs?: number, stdinData?: string }} [opts]
  * @returns {Promise<string>}
  */
 function runCli(command, args, opts = {}) {
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const stdinData = opts.stdinData;
 
   return new Promise((resolve, reject) => {
     const child = execFile(
@@ -188,10 +200,13 @@ function runCli(command, args, opts = {}) {
       },
     );
 
-    // Close stdin immediately so the child process doesn't wait for piped input.
-    // execFile creates a pipe for stdin by default; leaving it open causes
-    // the child to hang indefinitely waiting for EOF.
-    child.stdin?.end();
+    // Pipe prompt via stdin to avoid arg-quoting issues, then close.
+    child.stdin?.on("error", () => {}); // ignore EPIPE if child exits early
+    if (stdinData != null) {
+      child.stdin?.end(stdinData, "utf8");
+    } else {
+      child.stdin?.end();
+    }
 
     child.on("error", (err) => {
       reject(new Error(`Failed to start ${command}: ${err.message}`));
@@ -235,7 +250,7 @@ function runCodexPassthrough({ model, modelReasoningEffort }) {
 // ---------------------------------------------------------------------------
 
 async function main() {
-  const { provider: providerName, model, modelReasoningEffort } = parseArgs();
+  const { provider: providerName, model, modelReasoningEffort, sandbox } = parseArgs();
   const backend = CLI_BACKENDS[providerName];
 
   if (!backend) {
@@ -250,6 +265,10 @@ async function main() {
     return;
   }
 
+  if (backend.extraProperties.sandbox) {
+    backend.extraProperties.sandbox.default = sandbox;
+  }
+
   const server = new Server(
     { name: "mcp-agents", version: VERSION },
     { capabilities: { tools: {} } },
@@ -330,16 +349,19 @@ async function main() {
 
     const extraOpts = {};
     for (const key of Object.keys(backend.extraProperties)) {
-      if (params.arguments?.[key] != null) {
-        extraOpts[key] = params.arguments[key];
-      }
+      extraOpts[key] = params.arguments?.[key] ?? backend.extraProperties[key].default;
     }
 
-    const cliArgs = backend.buildArgs(prompt, extraOpts);
+    const cliArgs = backend.stdinPrompt
+      ? backend.buildArgs(extraOpts)
+      : backend.buildArgs(prompt, extraOpts);
+    const cliOpts = backend.stdinPrompt
+      ? { timeoutMs, stdinData: prompt }
+      : { timeoutMs };
 
     logErr(`[mcp-agents] tools/call: running ${backend.command} …`);
     try {
-      const output = await runCli(backend.command, cliArgs, { timeoutMs });
+      const output = await runCli(backend.command, cliArgs, cliOpts);
       logErr("[mcp-agents] tools/call: done");
       return {
         content: [{ type: "text", text: output || "" }],