@baitong-dev/execute-command-mcp 0.0.1

package/ExecuteCommandMcpServer.js

@@ -0,0 +1,660 @@
+#!/usr/bin/env bun
+"use strict";
+/**
+ * Execute Command MCP Server v1.0
+ * Provides direct command execution tools that bypass Claude Code's
+ * slow haiku-based pre-flight checks.
+ *
+ * Features:
+ * - execute_command: Single command execution
+ * - execute_command_sequence: Sequential commands in a single shell session (stateful)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const zod_1 = __importDefault(require("zod"));
+const HOME_APP_DIR = '.baitong-desktop';
+function getBinaryName(name) {
+    if (process.platform == 'win32') {
+        return `${name}.exe`;
+    }
+    return name;
+}
+function getBinaryPath(name) {
+    if (!name) {
+        return path_1.default.join(os_1.default.homedir(), HOME_APP_DIR, 'bin');
+    }
+    const binaryName = getBinaryName(name);
+    const binariesDir = path_1.default.join(os_1.default.homedir(), HOME_APP_DIR, 'bin');
+    const binariesDirExists = fs.existsSync(binariesDir);
+    return binariesDirExists ? path_1.default.join(binariesDir, binaryName) : binaryName;
+}
+function isBinaryExists(name) {
+    const cmd = getBinaryPath(name);
+    return fs.existsSync(cmd);
+}
+function handleCommand(fullCommand) {
+    const args = fullCommand.split(' ').map(arg => arg.trim());
+    const command = args.shift();
+    if (!command) {
+        throw new Error('No command specified');
+    }
+    let cmd = command;
+    if (command === 'bun' || command === 'npx' || command === 'node') {
+        if (isBinaryExists('bun')) {
+            // Fall back to bundled bun
+            cmd = getBinaryPath('bun');
+            // Transform args for bun x format
+            if (args && args.length > 0) {
+                if (command === 'npx') {
+                    // Transform args for npx format npx xxx -> bun x -y xxx
+                    if (!args.includes('-y')) {
+                        args.unshift('-y');
+                    }
+                    if (!args.includes('x')) {
+                        args.unshift('x');
+                    }
+                }
+            }
+        }
+        else {
+            // Neither npx nor bun available
+            throw new Error('npx not found in PATH and bundled bun is not available. This may indicate an installation issue.\n' +
+                'Please either:\n' +
+                '1. Install Node.js (which includes npx) from https://nodejs.org\n' +
+                '2. Run the MCP dependencies installer from Settings\n' +
+                '3. Restart the application if you recently installed Node.js');
+        }
+    }
+    else if (command === 'uvx' || command === 'uv') {
+        if (isBinaryExists(command)) {
+            // Fall back to bundled version
+            cmd = getBinaryPath(command);
+        }
+        else {
+            // Neither system nor bundled available
+            throw new Error(`${command} not found in PATH and bundled version is not available. This may indicate an installation issue.\n` +
+                'Please either:\n' +
+                '1. Install uv from https://github.com/astral-sh/uv\n' +
+                '2. Run the MCP dependencies installer from Settings\n' +
+                `3. Restart the application if you recently installed ${command}`);
+        }
+    }
+    return {
+        command: cmd,
+        args
+    };
+}
+const server = new mcp_js_1.McpServer({
+    name: 'execute-command-mcp',
+    version: '1.0.0'
+}, {
+    capabilities: {
+        logging: {}
+    }
+});
+// =============================================================================
+// Constants
+// =============================================================================
+// Default working directory: env var > process.cwd() > HOME > /tmp
+const DEFAULT_CWD = process.env.FAST_BASH_DEFAULT_CWD || process.cwd() || process.env.HOME || '/tmp';
+// Grace period before SIGKILL (ms)
+const GRACEFUL_TIMEOUT_MS = 5000;
+// Reserved characters for truncation ellipsis
+const TRUNCATION_ELLIPSIS_RESERVE = 50;
+// Exit code for timeout (shell convention)
+const EXIT_CODE_TIMEOUT = 124;
+// Sudo rejection message
+const SUDO_REJECTION_MESSAGE = '[REJECTED] sudo commands cannot be executed. Please STOP and ask human user to run it for you!\n';
+/**
+ * Check if a command contains sudo
+ * Matches: sudo at start, after semicolon, after &&, after ||, after |, after $(, after backtick
+ */
+function containsSudo(command) {
+    // Match sudo as a standalone command (not part of another word like "pseudocode")
+    return /(?:^|[;&|`$()]\s*)sudo(?:\s|$)/m.test(command);
+}
+// Default timeout for sequence commands (5 minutes)
+const DEFAULT_SEQUENCE_TIMEOUT = 300000;
+// =============================================================================
+// Batch 1.1: DRY Output Formatting
+// =============================================================================
+/**
+ * Format command line with $ prefix
+ */
+function formatCommandLine(command) {
+    return `$ ${command}`;
+}
+/**
+ * Format timing
+ */
+function formatTiming(durationMs) {
+    return `[${durationMs}ms]`;
+}
+/**
+ * Middle-truncate output to preserve beginning and end
+ */
+function middleTruncate(text, maxLength) {
+    if (text.length <= maxLength)
+        return text;
+    const halfLength = Math.floor((maxLength - TRUNCATION_ELLIPSIS_RESERVE) / 2);
+    const start = text.slice(0, halfLength);
+    const end = text.slice(-halfLength);
+    const truncatedBytes = text.length - maxLength;
+    return `${start}\n\n... [truncated ${truncatedBytes} characters] ...\n\n${end}`;
+}
+/**
+ * Classify error type from exit code and error conditions
+ */
+function classifyErrorType(exitCode, killed, forceKilled, spawnError, cwdError) {
+    if (cwdError)
+        return 'cwd_not_found';
+    if (spawnError) {
+        if (spawnError.code === 'ENOENT')
+            return 'spawn_error';
+        return 'spawn_error';
+    }
+    if (killed)
+        return forceKilled ? 'killed' : 'timeout';
+    if (exitCode === 127)
+        return 'command_not_found';
+    if (exitCode === 126)
+        return 'permission_denied';
+    return undefined;
+}
+/**
+ * Format command result for output (Batch 1.2: includes errorType)
+ */
+function formatResult(result, options = {}) {
+    const { description, timeout, command, showTiming = false } = options;
+    let output = '';
+    if (description)
+        output += `=== ${description} ===\n`;
+    if (command)
+        output += `${formatCommandLine(command)}\n`;
+    if (result.stdout)
+        output += result.stdout;
+    if (result.stderr)
+        output += `\n[stderr]: ${result.stderr}`;
+    if (result.killed) {
+        if (result.forceKilled) {
+            output += `\n[timeout after ${(timeout || 30000) + GRACEFUL_TIMEOUT_MS}ms, SIGKILL]`;
+        }
+        else {
+            output += `\n[timeout after ${timeout || 30000}ms, SIGTERM]`;
+        }
+    }
+    if (result.errorType && result.errorType !== 'timeout') {
+        output += `\n[errorType: ${result.errorType}]`;
+    }
+    output += `\n[exit code: ${result.exitCode}]`;
+    if (showTiming && result.durationMs !== undefined) {
+        output += `\n${formatTiming(result.durationMs)}`;
+    }
+    return output.trim() || '(no output)';
+}
+// =============================================================================
+// Batch 5.1: File Output Helper
+// =============================================================================
+/**
+ * Write output to file (before truncation)
+ * Returns error message on failure, undefined on success
+ */
+function writeOutputToFile(filePath, content) {
+    try {
+        fs.writeFileSync(filePath, content, 'utf8');
+        return undefined;
+    }
+    catch (err) {
+        return err.message;
+    }
+}
+/**
+ * Execute commands sequentially in a single shell session (stateful)
+ */
+async function executeSequence(options) {
+    var _a;
+    const { commands, stopOnFailure = true, continueOnCodes = [0], cwd = DEFAULT_CWD, timeout = DEFAULT_SEQUENCE_TIMEOUT
+    // outputFile
+     } = options;
+    // Empty commands validation
+    if (commands.length === 0) {
+        return {
+            results: [],
+            totalDurationMs: 0,
+            succeeded: 0,
+            failed: 0,
+            executed: 0
+        };
+    }
+    // CWD Validation
+    if (!fs.existsSync(cwd)) {
+        return {
+            results: [
+                {
+                    index: 0,
+                    command: ((_a = commands[0]) === null || _a === void 0 ? void 0 : _a.command) || '',
+                    stdout: '',
+                    stderr: `[error]: Working directory does not exist: ${cwd}`,
+                    exitCode: 1,
+                    durationMs: 0,
+                    stopped: true,
+                    stopReason: 'cwd_not_found'
+                }
+            ],
+            totalDurationMs: 0,
+            succeeded: 0,
+            failed: 1,
+            executed: 0
+        };
+    }
+    let newCwd = cwd;
+    let newTimeout = timeout;
+    const results = [];
+    let succeeded = 0;
+    let failed = 0;
+    let stoppedAt = undefined;
+    let totalDurationMs = 0;
+    let index = 0;
+    try {
+        for (let i = 0; i < commands.length; i++) {
+            index = i;
+            const command = commands[i].command;
+            if (command.startsWith('cd ')) {
+                // 每次执行cd命令，不执行exec了
+                newCwd = path_1.default.resolve(newCwd, command.replace('cd ', ''));
+                succeeded++;
+                results.push({
+                    index,
+                    command,
+                    stdout: '',
+                    stderr: '',
+                    exitCode: 0,
+                    durationMs: 0
+                });
+                continue;
+            }
+            // 每次执行非cd命令
+            const result = await executeCommand(Object.assign(Object.assign({}, options), { cwd: newCwd, timeout: newTimeout, command }));
+            const { stdout, stderr, exitCode, killed, durationMs } = result;
+            const sequenceResult = {
+                index,
+                command,
+                stdout,
+                stderr,
+                exitCode,
+                durationMs,
+                stopped: false
+            };
+            totalDurationMs += durationMs;
+            newTimeout = timeout - durationMs;
+            if (sequenceResult.exitCode != null && continueOnCodes.includes(sequenceResult.exitCode)) {
+                succeeded++;
+            }
+            else {
+                failed++;
+                if (stopOnFailure && stoppedAt === undefined) {
+                    stoppedAt = i;
+                }
+            }
+            if (stoppedAt === i) {
+                sequenceResult.stopped = true;
+                sequenceResult.stopReason = killed
+                    ? 'timeout'
+                    : `exit code ${exitCode} not in continue_on_codes`;
+            }
+            results.push(sequenceResult);
+            if (stoppedAt !== undefined)
+                break;
+        }
+    }
+    catch (_) {
+        //
+    }
+    return {
+        results,
+        totalDurationMs,
+        succeeded,
+        failed,
+        executed: results.length,
+        stoppedAt: 0
+    };
+}
+// =============================================================================
+// Tool Definitions
+// =============================================================================
+const bashInputSchema = zod_1.default.object({
+    command: zod_1.default.string().min(1).describe('The command to execute'),
+    cwd: zod_1.default.string().describe('Working directory'),
+    timeout: zod_1.default
+        .number()
+        .min(1)
+        .max(600000)
+        .optional()
+        .describe('Timeout in milliseconds (optional, default 30000, max 600000)'),
+    description: zod_1.default
+        .string()
+        .optional()
+        .describe('Short description of what this command does (for logging)'),
+    env: zod_1.default
+        .record(zod_1.default.string(), zod_1.default.string())
+        .optional()
+        .describe('Additional environment variables to set'),
+    stdin: zod_1.default.string().optional().describe("Input to pipe to the command's stdin"),
+    maxOutput: zod_1.default
+        .number()
+        .min(1)
+        .max(1000000)
+        .optional()
+        .describe('Maximum output length before middle-truncation (default 30000)'),
+    outputFile: zod_1.default.string().optional().describe('File path to save full stdout (before truncation)'),
+    stderrFile: zod_1.default.string().optional().describe('File path to save full stderr (before truncation)'),
+    loginShell: zod_1.default
+        .boolean()
+        .optional()
+        .describe('Run as login shell (-l flag) to source .profile/.bash_profile (default: false)')
+});
+/**
+ * Execute a command and return result
+ */
+function executeCommand(options) {
+    const { command, cwd = DEFAULT_CWD, timeout = 30000, env, stdin, maxOutput = 30000, outputFile, stderrFile
+    // loginShell = false
+     } = options;
+    return new Promise(resolve => {
+        var _a, _b, _c, _d;
+        const startTime = Date.now();
+        // Batch 1.3: CWD Validation
+        if (!fs.existsSync(cwd)) {
+            resolve({
+                stdout: '',
+                stderr: `[error]: Working directory does not exist: ${cwd}`,
+                exitCode: 1,
+                killed: false,
+                forceKilled: false,
+                errorType: 'cwd_not_found',
+                durationMs: Date.now() - startTime
+            });
+            return;
+        }
+        const mergedEnv = Object.assign(Object.assign({}, process.env), env);
+        let proc;
+        try {
+            // Use -lc for login shell (sources .profile), -c for regular
+            // const shellArgs = loginShell ? ['-lc', command] : ['-c', command]
+            const handledCommand = handleCommand(command);
+            console.log(handledCommand);
+            proc = (0, child_process_1.spawn)(handledCommand.command, handledCommand.args, {
+                cwd,
+                env: mergedEnv,
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+        }
+        catch (err) {
+            resolve({
+                stdout: '',
+                stderr: `[error]: Failed to spawn process: ${err.message}`,
+                exitCode: 1,
+                killed: false,
+                forceKilled: false,
+                errorType: 'spawn_error',
+                durationMs: Date.now() - startTime
+            });
+            return;
+        }
+        let stdout = '';
+        let stderr = '';
+        let killed = false;
+        let forceKilled = false;
+        let completed = false;
+        let graceTimer;
+        // Batch 5.2: Graceful Timeout - SIGTERM first, then SIGKILL after grace period
+        const timer = setTimeout(() => {
+            killed = true;
+            proc.kill('SIGTERM');
+            // Grace period before SIGKILL
+            graceTimer = setTimeout(() => {
+                if (!completed) {
+                    proc.kill('SIGKILL');
+                    forceKilled = true;
+                }
+            }, GRACEFUL_TIMEOUT_MS);
+        }, timeout);
+        if (stdin) {
+            (_a = proc.stdin) === null || _a === void 0 ? void 0 : _a.write(stdin);
+            (_b = proc.stdin) === null || _b === void 0 ? void 0 : _b.end();
+        }
+        (_c = proc.stdout) === null || _c === void 0 ? void 0 : _c.on('data', data => {
+            stdout += data.toString();
+        });
+        (_d = proc.stderr) === null || _d === void 0 ? void 0 : _d.on('data', data => {
+            stderr += data.toString();
+        });
+        proc.on('close', code => {
+            completed = true;
+            clearTimeout(timer);
+            if (graceTimer)
+                clearTimeout(graceTimer);
+            const durationMs = Date.now() - startTime;
+            // Batch 5.1: Write to files BEFORE truncation
+            if (outputFile) {
+                writeOutputToFile(outputFile, stdout);
+            }
+            if (stderrFile) {
+                writeOutputToFile(stderrFile, stderr);
+            }
+            // Apply truncation for response
+            let truncatedStdout = stdout;
+            let truncatedStderr = stderr;
+            if (truncatedStdout.length > maxOutput) {
+                truncatedStdout = middleTruncate(truncatedStdout, maxOutput);
+            }
+            if (truncatedStderr.length > maxOutput) {
+                truncatedStderr = middleTruncate(truncatedStderr, maxOutput);
+            }
+            const errorType = classifyErrorType(code, killed, forceKilled);
+            resolve({
+                stdout: truncatedStdout,
+                stderr: truncatedStderr,
+                exitCode: killed ? EXIT_CODE_TIMEOUT : code,
+                killed,
+                forceKilled,
+                errorType,
+                durationMs
+            });
+        });
+        proc.on('error', err => {
+            completed = true;
+            clearTimeout(timer);
+            if (graceTimer)
+                clearTimeout(graceTimer);
+            const durationMs = Date.now() - startTime;
+            resolve({
+                stdout: '',
+                stderr: err.message,
+                exitCode: 1,
+                killed: false,
+                forceKilled: false,
+                errorType: classifyErrorType(1, false, false, err),
+                durationMs
+            });
+        });
+    });
+}
+server.registerTool('execute_command', {
+    description: 'Execute a command directly. Returns stdout, stderr, and exit code.',
+    inputSchema: bashInputSchema
+}, async (args) => {
+    const command = args.command;
+    if (command.includes('&&')) {
+        return executeSequenceCallback({
+            commands: command.split('&&').map(cmd => ({ command: cmd.trim() })),
+            cwd: args.cwd,
+            timeout: args.timeout,
+            env: args.env,
+            maxOutput: args.maxOutput,
+            outputFile: args.outputFile
+        });
+    }
+    // Reject sudo commands
+    if (containsSudo(command)) {
+        return {
+            isError: true,
+            content: [{ type: 'text', text: `${SUDO_REJECTION_MESSAGE}$ ${command}` }]
+        };
+    }
+    const result = await executeCommand(args);
+    // Use formatFullOutput for DRY consistency
+    let output = formatResult(result, {
+        description: args.description,
+        timeout: args.timeout,
+        command,
+        showTiming: true
+    });
+    // Add file save notices
+    if (args.outputFile) {
+        output += `\n[stdout saved to: ${args.outputFile}]`;
+    }
+    if (args.stderrFile) {
+        output += `\n[stderr saved to: ${args.stderrFile}]`;
+    }
+    return {
+        isError: result.exitCode !== 0,
+        content: [{ type: 'text', text: output }]
+    };
+});
+const bashSequenceInputSchema = zod_1.default.object({
+    commands: zod_1.default
+        .array(zod_1.default.object({
+        command: zod_1.default.string().describe('The command to execute'),
+        description: zod_1.default.string().optional().describe('Short description of what this command does')
+    }))
+        .describe('Array of commands to execute sequentially in one shell'),
+    cwd: zod_1.default.string().describe('Initial working directory'),
+    stopOnFailure: zod_1.default
+        .boolean()
+        .optional()
+        .describe('Stop execution if a command fails (default: true)'),
+    continueOnCodes: zod_1.default
+        .array(zod_1.default.number())
+        .optional()
+        .describe('Exit codes that are considered success (default: [0])'),
+    timeout: zod_1.default
+        .number()
+        .optional()
+        .describe('Overall timeout for all commands in ms (default: 300000)'),
+    maxOutput: zod_1.default
+        .number()
+        .min(1)
+        .max(1000000)
+        .optional()
+        .describe('Maximum output length before middle-truncation (default 30000)'),
+    env: zod_1.default
+        .record(zod_1.default.string(), zod_1.default.string())
+        .optional()
+        .describe('Additional environment variables to set'),
+    outputFile: zod_1.default.string().optional().describe('File path to save full output (before truncation)')
+});
+const executeSequenceCallback = async (args) => {
+    var _a;
+    const commands = args.commands;
+    // Reject any command containing sudo
+    for (let i = 0; i < commands.length; i++) {
+        if (containsSudo(commands[i].command)) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: 'text',
+                        text: `${SUDO_REJECTION_MESSAGE}[${i + 1}] $ ${commands[i].command}`
+                    }
+                ]
+            };
+        }
+    }
+    const seqResult = await executeSequence(args);
+    // Format output per Batch 4.4 spec
+    const outputParts = seqResult.results.map(r => {
+        const header = r.description
+            ? `[${r.index}] === ${r.description} ===`
+            : `[${r.index}] === Command ${r.index} ===`;
+        const cmdLine = formatCommandLine(r.command);
+        let body = '';
+        if (r.stdout)
+            body += r.stdout;
+        if (r.stderr)
+            body += `\n[stderr]: ${r.stderr}`;
+        body += `\n[exit code: ${r.exitCode}]`;
+        if (r.stopped && r.stopReason) {
+            body += `\n[stopped - ${r.stopReason}]`;
+        }
+        const timing = formatTiming(r.durationMs);
+        return `${header}\n${cmdLine}\n${body.trim()}\n${timing}`;
+    });
+    // Summary
+    let summary = `\n=== Summary ===`;
+    summary += `\nTotal: ${seqResult.totalDurationMs}ms | Executed: ${seqResult.executed}/${commands.length} | Succeeded: ${seqResult.succeeded} | Failed: ${seqResult.failed}`;
+    if (seqResult.stoppedAt !== undefined) {
+        const stoppedCmd = seqResult.results[seqResult.stoppedAt];
+        const stoppedDesc = (stoppedCmd === null || stoppedCmd === void 0 ? void 0 : stoppedCmd.description) || ((_a = stoppedCmd === null || stoppedCmd === void 0 ? void 0 : stoppedCmd.command) === null || _a === void 0 ? void 0 : _a.slice(0, 30)) || 'unknown';
+        summary += `\nStopped at: [${seqResult.stoppedAt + 1}] ${stoppedDesc}`;
+    }
+    let response = outputParts.join('\n\n') + summary;
+    if (args.outputFile) {
+        response += `\n[output saved to: ${args.outputFile}]`;
+    }
+    return {
+        isError: seqResult.failed > 0,
+        content: [{ type: 'text', text: response }]
+    };
+};
+server.registerTool('execute_command_sequence', {
+    description: 'Execute commands sequentially in a SINGLE shell session (stateful). Unlike parallel, cd/export commands persist between steps. Use for workflows where commands depend on each other. Note: stderr is combined for the whole script and assigned to the last executed command.',
+    inputSchema: bashSequenceInputSchema
+}, executeSequenceCallback);
+// =============================================================================
+// Start Server
+// =============================================================================
+const transport = new stdio_js_1.StdioServerTransport();
+server.connect(transport);
+console.error('Execute Command MCP server v1.0 running');

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@baitong-dev/execute-command-mcp",
+  "version": "0.0.1",
+  "main": "ExecuteCommandMcpServer.js",
+  "bin": {
+    "@baitong-dev/skills-mcp": "./ExecuteCommandMcpServer.js"
+  },
+  "files": [
+    "ExecuteCommandMcpServer.js",
+    "README.md"
+  ],
+  "scripts": {},
+  "keywords": [
+    "mcp",
+    "skills"
+  ],
+  "description": "execute-command-mcp",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.1",
+    "commander": "^14.0.3",
+    "zod": "^4.3.4"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  }
+}