Shell-MCP

Instructions

Implementation Reference

• src/index.ts:45-85 (handler)

  Main MCP tool call handler that specifically maps tool name 'shell_cat' (by replacing 'shell_' with '') to internal 'shell.cat' config, validates args, executes via CommandExecutor, collects stdout, and returns text content.

  server.setRequestHandler(CallToolRequestSchema, async (request) => {
    try {
      const command = String(request.params?.name || '');
      const fullCommand = `shell.${command.replace('shell_', '')}`;  // Replace shell_ back to shell.
      
      if (!(fullCommand in allowedCommands)) {
        return {
          content: [{ type: "text", text: `Unknown command: ${command}` }],
          isError: true
        };
      }
      
      const actualCommand = allowedCommands[fullCommand].command;
      const args = Array.isArray(request.params?.arguments?.args)
        ? request.params.arguments.args.map(String)
        : [];
    
      validator.validateCommand(actualCommand, args);
      const stream = await executor.execute(actualCommand, args);
    
      return {
        content: [{
          type: "text",
          text: await new Promise((resolve, reject) => {
            const chunks: Buffer[] = [];
            stream.stdout.on('data', (chunk: Buffer) => chunks.push(chunk));
            stream.stdout.on('end', () => resolve(Buffer.concat(chunks).toString()));
            stream.stdout.on('error', reject);
          })
        }]
      };
    } catch (error) {
      return {
        content: [{ 
          type: "text", 
          text: `Command execution failed: ${error instanceof Error ? error.message : String(error)}` 
        }],
        isError: true
      };
    }
  });

• src/index.ts:27-43 (registration)

  Registers the 'shell_cat' tool (by converting 'shell.cat' key to 'shell_cat') with its description and generic input schema for string array args.

  server.setRequestHandler(ListToolsRequestSchema, async () => {
    const tools = Object.entries(allowedCommands).map(([name, config]) => ({
      name: name.replace('shell.', 'shell_'),  // Replace shell. with shell_
      description: config.description,
      inputSchema: {
        type: "object",
        properties: {
          args: {
            type: "array",
            items: { type: "string" },
            description: "Command arguments"
          }
        }
      }
    }));
    return { tools };
  });

• src/config/allowlist.ts:21-26 (registration)

  Allowlist configuration entry for 'shell.cat' command, defining the executable 'cat', description, allowed arguments, and timeout used for the 'shell_cat' tool.

  'shell.cat': {
    command: 'cat',
    description: 'Concatenate and display file contents',
    allowedArgs: ['-n', '-b', '--help', '*'],
    timeout: 3000
  },

• src/core/executor.ts:31-121 (handler)

  Core execution logic that spawns the child process for the base command ('cat' for shell.cat/shell_cat) with provided arguments, handling streams, timeouts, and errors.

  async execute(
    command: string,
    args: string[] = [],
    options: ExecuteOptions = {}
  ): Promise<{ stdout: Readable }> {
    const commandKey = `${command} ${args.join(' ')}`;
    
    try {
      // Check security
      await this.securityChecker.validateCommand(command, args, options);
  
      // Check cache
      const cached = this.cache.get(commandKey);
      if (cached) {
        this.logger.debug('Using cached command result', { command, args });
        return this.createStreamFromCache(cached);
      }
  
      // Remove 'shell.' prefix for execution
      const baseCommand = command.replace('shell.', '');
  
      // Execute command
      this.logger.debug('Starting command execution', { command, args, options });
      const childProcess = spawn(baseCommand, args, {
        stdio: ['ignore', 'pipe', 'pipe'],
        timeout: options.timeout,
        cwd: options.cwd,
        env: {
          ...process.env,
          ...options.env
        },
        signal: options.signal
      });
  
      this.currentProcess = childProcess;
  
      // Error handling
      childProcess.on('error', (error: Error) => {
        this.logger.error('Command execution error', {
          command,
          args,
          error: error.message
        });
        throw new ToolError(
          'PROCESS_ERROR',
          'Command execution error',
          { command, args, error: error.message }
        );
      });
  
      // Timeout handling
      if (options.timeout) {
        setTimeout(() => {
          if (childProcess.exitCode === null) {
            this.logger.warn('Command execution timeout', {
              command,
              args,
              timeout: options.timeout
            });
            childProcess.kill();
            throw new ToolError(
              'TIMEOUT',
              'Command execution timeout',
              { command, args, timeout: options.timeout }
            );
          }
        }, options.timeout);
      }
  
      if (!childProcess.stdout) {
        throw new ToolError(
          'STREAM_ERROR',
          'Unable to get command output stream',
          { command, args }
        );
      }
  
      // Monitor process status
      childProcess.on('exit', (code, signal) => {
        this.logger.debug('Command execution completed', {
          command,
          args,
          exitCode: code,
          signal
        });
      });
  
      return {
        stdout: childProcess.stdout
      };