mcp-server-commands 0.8.0 → 0.8.1

package/build/exec-utils.js

@@ -4,50 +4,92 @@ import { performance } from "perf_hooks";
 import { is_verbose, verbose_log } from "./logging.js";
 import { resultFor } from "./messages.js";
 import { errorResult } from "./messages.js";
+/**
+ * Helper class that provides typed getters for the keys accepted by
+ * {@link runProcess}. It wraps a {@link RunProcessArgs} object and casts the
+ * values to the expected runtime types.
+ */
+export class RunProcessArgsHelper {
+    raw;
+    constructor(raw) {
+        this.raw = raw ?? {};
+    }
+    /** Working directory – string if supplied, otherwise undefined */
+    get cwd() {
+        const v = this.raw.cwd;
+        return v == null ? undefined : String(v);
+    }
+    /** Text to write to STDIN – string if supplied, otherwise undefined */
+    get stdin_text() {
+        const v = this.raw.stdin_text;
+        return v == null ? undefined : String(v);
+    }
+    /** Shell command line – string if supplied, otherwise undefined */
+    get commandLine() {
+        const v = this.raw.command_line;
+        return v == null ? undefined : String(v);
+    }
+    /** Executable argv – array of strings if supplied, otherwise undefined */
+    get argv() {
+        const v = this.raw.argv;
+        if (!Array.isArray(v))
+            return undefined;
+        return v.map((item) => String(item));
+    }
+    /** Timeout in milliseconds – number if supplied, otherwise undefined */
+    /** Timeout in milliseconds – always a number (default 30_000) */
+    get timeoutMs() {
+        const v = this.raw.timeout_ms;
+        const n = Number(v);
+        return Number.isNaN(n) ? 30_000 : n;
+    }
+    /** True if a shell command line is provided */
+    get isShellMode() {
+        return Boolean(this.commandLine);
+    }
+    /** True if an argv array with at least one element is provided */
+    get isExecutableMode() {
+        return Array.isArray(this.raw.argv) && (this.argv?.length ?? 0) > 0;
+    }
+}
 export function runProcess(runProcessArgs) {
     const startTime = performance.now();
+    const args = new RunProcessArgsHelper(runProcessArgs);
+    if (args.isShellMode && args.isExecutableMode) {
+        return Promise.resolve(errorResult("Cannot pass both 'command_line' and 'argv'. Use one or the other."));
+    }
+    if (!args.isShellMode && !args.isExecutableMode) {
+        return Promise.resolve(errorResult("Either 'command_line' (string) or 'argv' (array) is required."));
+    }
     const options = {
         // spawn options: https://nodejs.org/api/child_process.html#child_processspawncommand-args-options
         encoding: "utf8"
     };
-    if (runProcessArgs?.cwd) {
-        options.cwd = String(runProcessArgs.cwd);
+    if (args.cwd) {
+        options.cwd = args.cwd;
     }
-    const stdin = runProcessArgs?.stdin ? String(runProcessArgs.stdin) : undefined;
-    // ---------------------------------------------------------------------
-    // RunProcess argument handling – determine the actual command and args.
-    // ---------------------------------------------------------------------
-    const isShellMode = Boolean(runProcessArgs?.command_line);
-    const isExecutableMode = Array.isArray(runProcessArgs?.argv) && (runProcessArgs?.argv).length > 0;
-    if (isShellMode && isExecutableMode) {
-        return Promise.resolve(errorResult("Cannot pass both 'command_line' and 'argv'. Use one or the other."));
-    }
-    if (!isShellMode && !isExecutableMode) {
-        return Promise.resolve(errorResult("Either 'command_line' (string) or 'argv' (array) is required."));
-    }
-    // Resolve the command/args based on the mode.
-    let execCommand = "";
-    let execArgs = [];
-    if (isShellMode) {
+    let spawnCommand = "";
+    let spawnArgs = [];
+    if (args.isShellMode) {
         options.shell = true;
-        execCommand = String(runProcessArgs.command_line);
-        execArgs = [];
+        spawnCommand = String(args.commandLine);
+        spawnArgs = [];
     }
     else {
         options.shell = false;
-        const argv = runProcessArgs?.argv;
-        execCommand = argv[0];
-        execArgs = argv.slice(1);
+        const argv = args.argv;
+        spawnCommand = argv[0];
+        spawnArgs = argv.slice(1);
     }
     const logWithElapsedTime = (msg, ...rest) => {
         if (!is_verbose)
             return;
         const elapsed = ((performance.now() - startTime) / 1000).toFixed(3);
-        verbose_log(`[${elapsed}s] ${msg}`, ...rest, execCommand, execArgs);
+        verbose_log(`[${elapsed}s] ${msg}`, ...rest, spawnCommand, spawnArgs);
     };
     let child_pid;
     const promise = new Promise((resolve, reject) => {
-        if (!stdin) {
+        if (!args.stdin_text) {
             // PRN windowsHide on Windows, signal, killSignal
             // FYI spawn_options.stdio => default is perfect ['pipe', 'pipe', 'pipe'] 
             //     order: [STDIN, STDOUT, STDERR]
@@ -74,13 +116,13 @@ export function runProcess(runProcessArgs) {
                 resolve(resultFor(result));
             }
         };
-        const child = spawn(execCommand, execArgs, options);
+        const child = spawn(spawnCommand, spawnArgs, options);
         logWithElapsedTime(`START SPAWN child.pid: ${child.pid}`);
         child_pid = child.pid;
         let stdout = "";
         let stderr = "";
-        if (child.stdin && stdin) {
-            child.stdin.write(stdin);
+        if (child.stdin && args.stdin_text) {
+            child.stdin.write(args.stdin_text);
             child.stdin.end();
         }
         if (child.stdout) {
@@ -107,10 +149,6 @@ export function runProcess(runProcessArgs) {
         });
         // Timeout handling – kill the whole process group after the supplied timeout.
         let timer = null;
-        let timeoutMs = Number(runProcessArgs?.timeout_ms);
-        if (Number.isNaN(timeoutMs)) {
-            timeoutMs = 30_000;
-        }
         timer = setTimeout(() => {
             if (process.platform !== "win32") {
                 if (child.pid) {
@@ -139,7 +177,7 @@ export function runProcess(runProcessArgs) {
             const clearKill = () => clearTimeout(killTimeout);
             child.once("exit", clearKill);
             child.once("close", clearKill);
-        }, timeoutMs);
+        }, args.timeoutMs);
         child.on("error", (err) => {
             logWithElapsedTime("ERROR");
             // ChildProcess 'error' docs: https://nodejs.org/api/child_process.html#event-error

package/build/tools.js

@@ -36,7 +36,7 @@ export function registerTools(server) {
                                 type: "string",
                                 description: "Optional to set working directory",
                             },
-                            stdin: {
+                            stdin_text: {
                                 type: "string",
                                 description: "Optional text written to STDIN (written fully, then closed). Useful for heredoc-style input or file contents."
                             },

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mcp-server-commands",
-    "version": "0.8.0",
+    "version": "0.8.1",
     "description": "An MCP server to run arbitrary commands",
     "private": false,
     "type": "module",