@dollhousemcp/mcp-server/dist/security/commandValidator.js

DollhouseMCP - A Model Context Protocol (MCP) server that enables dynamic AI persona management from markdown files, allowing Claude and other compatible AI assistants to activate and switch between different behavioral personas.

import * as child_process from 'child_process';
import { RegexValidator } from './regexValidator.js';
import { SECURITY_LIMITS } from './constants.js';
const ALLOWED_COMMANDS = {
    // SECURITY FIX: Added 'clone' command to git allowlist
    // Previously: npm installation feature would fail with "Argument not allowed: clone"
    // Now: git clone command is allowed for npm installation functionality
    git: ['pull', 'status', 'log', 'rev-parse', 'branch', 'checkout', 'fetch', 'clone', '--abbrev-ref', 'HEAD', '--porcelain'],
    npm: ['install', 'run', 'audit', 'ci', '--version', 'build'],
    node: ['--version'],
    npx: ['--version']
};
export class CommandValidator {
    static sanitizeCommand(cmd, args) {
        if (!ALLOWED_COMMANDS[cmd]) {
            throw new Error(`Command not allowed: ${cmd}`);
        }
        const allowedArgs = ALLOWED_COMMANDS[cmd];
        for (const arg of args) {
            // Check if it's in allowed list or matches safe pattern
            if (!allowedArgs.includes(arg) && !this.isSafeArgument(arg)) {
                throw new Error(`Argument not allowed: ${arg}`);
            }
        }
    }
    static isSafeArgument(arg) {
        // Allow alphanumeric, dash, underscore, dot, and forward slash
        return RegexValidator.validate(arg, /^[a-zA-Z0-9\-_./]+$/, { maxLength: SECURITY_LIMITS.MAX_COMMAND_ARG_LENGTH });
    }
    static async secureExec(command, args, options) {
        this.sanitizeCommand(command, args);
        const safeOptions = {
            ...options,
            stdio: ['ignore', 'pipe', 'pipe'],
            env: {
                // SEC-03: Explicit allowlist instead of spreading full process.env
                PATH: '/usr/bin:/bin:/usr/local/bin',
                HOME: process.env.HOME,
                USER: process.env.USER,
                LANG: process.env.LANG,
                TERM: process.env.TERM,
                // Git operations need these
                GIT_AUTHOR_NAME: process.env.GIT_AUTHOR_NAME,
                GIT_AUTHOR_EMAIL: process.env.GIT_AUTHOR_EMAIL,
                GIT_COMMITTER_NAME: process.env.GIT_COMMITTER_NAME,
                GIT_COMMITTER_EMAIL: process.env.GIT_COMMITTER_EMAIL,
                // npm operations
                NODE_PATH: process.env.NODE_PATH,
                npm_config_cache: process.env.npm_config_cache,
            },
            cwd: options?.cwd || process.cwd(),
            timeout: options?.timeout || 30000 // 30 second default
        };
        return new Promise((resolve, reject) => {
            const proc = child_process.spawn(command, args, safeOptions);
            let stdout = '';
            let stderr = '';
            let timeoutHandle;
            let isCompleted = false;
            // Helper to safely resolve/reject only once
            const complete = (fn) => {
                if (!isCompleted) {
                    isCompleted = true;
                    if (timeoutHandle) {
                        clearTimeout(timeoutHandle);
                    }
                    fn();
                }
            };
            // Handle timeout
            if (options?.timeout) {
                timeoutHandle = setTimeout(() => {
                    proc.kill('SIGTERM');
                    complete(() => reject(new Error(`Command timed out after ${options.timeout}ms`)));
                }, options.timeout);
                timeoutHandle.unref();
            }
            proc.stdout?.on('data', (data) => stdout += data);
            proc.stderr?.on('data', (data) => stderr += data);
            proc.on('exit', (code) => {
                if (code === 0) {
                    complete(() => resolve(stdout.trim()));
                }
                else {
                    complete(() => reject(new Error(`Command failed (${code}): ${stderr}`)));
                }
            });
            proc.on('error', (error) => {
                complete(() => reject(error instanceof Error ? error : new Error(String(error))));
            });
        });
    }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"commandValidator.js","sourceRoot":"","sources":["../../src/security/commandValidator.ts"],"names":[],"mappings":"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","sourcesContent":["import * as child_process from 'child_process';\nimport { RegexValidator } from './regexValidator.js';\nimport { SECURITY_LIMITS } from './constants.js';\n\nconst ALLOWED_COMMANDS: Record<string, string[]> = {\n  // SECURITY FIX: Added 'clone' command to git allowlist\n  // Previously: npm installation feature would fail with \"Argument not allowed: clone\"\n  // Now: git clone command is allowed for npm installation functionality\n  git: ['pull', 'status', 'log', 'rev-parse', 'branch', 'checkout', 'fetch', 'clone', '--abbrev-ref', 'HEAD', '--porcelain'],\n  npm: ['install', 'run', 'audit', 'ci', '--version', 'build'],\n  node: ['--version'],\n  npx: ['--version']\n};\n\nexport class CommandValidator {\n  static sanitizeCommand(cmd: string, args: string[]): void {\n    if (!ALLOWED_COMMANDS[cmd]) {\n      throw new Error(`Command not allowed: ${cmd}`);\n    }\n    \n    const allowedArgs = ALLOWED_COMMANDS[cmd];\n    for (const arg of args) {\n      // Check if it's in allowed list or matches safe pattern\n      if (!allowedArgs.includes(arg) && !this.isSafeArgument(arg)) {\n        throw new Error(`Argument not allowed: ${arg}`);\n      }\n    }\n  }\n\n  private static isSafeArgument(arg: string): boolean {\n    // Allow alphanumeric, dash, underscore, dot, and forward slash\n    return RegexValidator.validate(arg, /^[a-zA-Z0-9\\-_./]+$/, { maxLength: SECURITY_LIMITS.MAX_COMMAND_ARG_LENGTH });\n  }\n\n  static async secureExec(command: string, args: string[], options?: child_process.SpawnOptions): Promise<string> {\n    this.sanitizeCommand(command, args);\n    \n    const safeOptions: child_process.SpawnOptions = {\n      ...options,\n      stdio: ['ignore', 'pipe', 'pipe'],\n      env: {\n        // SEC-03: Explicit allowlist instead of spreading full process.env\n        PATH: '/usr/bin:/bin:/usr/local/bin',\n        HOME: process.env.HOME,\n        USER: process.env.USER,\n        LANG: process.env.LANG,\n        TERM: process.env.TERM,\n        // Git operations need these\n        GIT_AUTHOR_NAME: process.env.GIT_AUTHOR_NAME,\n        GIT_AUTHOR_EMAIL: process.env.GIT_AUTHOR_EMAIL,\n        GIT_COMMITTER_NAME: process.env.GIT_COMMITTER_NAME,\n        GIT_COMMITTER_EMAIL: process.env.GIT_COMMITTER_EMAIL,\n        // npm operations\n        NODE_PATH: process.env.NODE_PATH,\n        npm_config_cache: process.env.npm_config_cache,\n      },\n      cwd: options?.cwd || process.cwd(),\n      timeout: options?.timeout || 30000 // 30 second default\n    };\n    \n    return new Promise((resolve, reject) => {\n      const proc = child_process.spawn(command, args, safeOptions);\n      \n      let stdout = '';\n      let stderr = '';\n      let timeoutHandle: NodeJS.Timeout | undefined;\n      let isCompleted = false;\n      \n      // Helper to safely resolve/reject only once\n      const complete = (fn: () => void) => {\n        if (!isCompleted) {\n          isCompleted = true;\n          if (timeoutHandle) {\n            clearTimeout(timeoutHandle);\n          }\n          fn();\n        }\n      };\n      \n      // Handle timeout\n      if (options?.timeout) {\n        timeoutHandle = setTimeout(() => {\n          proc.kill('SIGTERM');\n          complete(() => reject(new Error(`Command timed out after ${options.timeout}ms`)));\n        }, options.timeout);\n        timeoutHandle.unref();\n      }\n      \n      proc.stdout?.on('data', (data) => stdout += data);\n      proc.stderr?.on('data', (data) => stderr += data);\n      \n      proc.on('exit', (code) => {\n        if (code === 0) {\n          complete(() => resolve(stdout.trim()));\n        } else {\n          complete(() => reject(new Error(`Command failed (${code}): ${stderr}`)));\n        }\n      });\n      \n      proc.on('error', (error) => {\n        complete(() => reject(error instanceof Error ? error : new Error(String(error))));\n      });\n    });\n  }\n}"]}