MCP Connector

Automate Console Applications and Terminal Workflows

A production MCP server for full console/terminal automation - 40 tools for local and SSH sessions, output monitoring, and multi-language error detection.

Works with githubpowershellbashzshsh

Maintainer of this project? Claim this page to edit the listing.


90
Spark score
out of 100
Updated 5 months ago
Version 1.0.0
Models
universal

Add to Favorites

Why it matters

Enable AI assistants to fully interact with console applications, monitor output, detect errors, and automate terminal workflows, similar to how Playwright works for web browsers.

Outcomes

What it gets done

01

Create and manage local or SSH console sessions.

02

Send input and monitor output for console applications.

03

Automate terminal workflows with error detection and validation.

04

Execute commands and manage long-running background tasks.

Install

Add it to your toolbox

Run in your project directory:

curl -fsSL https://spark.entire.vc/get/vb-console-automation | bash

Capabilities

Tools your agent gets

console_create_session

Create local or SSH console sessions

console_send_input

Send text input to sessions

console_send_key

Send special keys (Enter, Ctrl+C, etc.)

console_get_output

Get filtered/paginated output with advanced search

console_get_stream

Stream output from long-running processes

console_wait_for_output

Wait for specific patterns in console output

console_stop_session

Stop active console sessions

console_list_sessions

List all active console sessions

+7 tools

Overview

Console Automation MCP Server

A production MCP server exposing 40 tools for creating and driving local or SSH console sessions - input, output streaming, multi-language error detection, and resource monitoring. Use when an agent needs to run and monitor real terminal workflows rather than issuing one-off shell commands blind.

What it does

Lets an AI assistant fully interact with console applications the way Playwright drives a web browser - creating and managing sessions, sending input, monitoring output, and detecting errors across up to 50 concurrent console sessions. Named tools cover session lifecycle (console_create_session for local or SSH sessions, console_stop_session, console_list_sessions, console_cleanup_sessions), interaction (console_send_input, console_send_key for special keys like Enter or Ctrl+C, console_execute_command for one-shot commands with output capture), output handling (console_get_output with filtering and pagination, console_get_stream for long-running processes, console_wait_for_output for pattern matching, console_clear_output), and diagnostics (console_detect_errors, console_get_resource_usage, console_get_session_state, console_get_command_history). Local shells covered include cmd, PowerShell, pwsh, bash, zsh, and sh, and remote sessions connect over SSH with password or key-based authentication, including passphrase support, with connection profiles that save and reuse SSH configurations for quick reconnects.

When to use - and when NOT to

Use it when an agent needs to run and monitor real terminal workflows - development servers, automated test suites, remote SSH sessions, background jobs - rather than issuing one-off shell commands blind. It requires no native code compilation and works across Windows, macOS, and Linux, installed via a PowerShell script on Windows, a shell script on macOS/Linux, a manual npm build, or a zero-install invocation. Error detection is built in across multiple programming languages' error, exception, and stack-trace patterns, so a monitored process's failures surface automatically rather than requiring the calling agent to parse raw output itself.

Capabilities

Complete terminal session management for up to 50 concurrent local or SSH sessions, interactive input and special-key sending, real-time filtered output monitoring and streaming, automatic multi-language error detection, resource usage statistics, saved SSH connection profiles, and built-in test-case validation tools - 40 tools total across session management, command execution, monitoring and alerts, profile management, background tasks, and test automation.

How to install

Run the platform installer (install.ps1 -Target claude on Windows, install.sh --target claude on macOS/Linux), build manually with npm install --production && npm run build, or skip installation entirely with npx @mcp/console-automation, then add the server to Claude Desktop's config:

{
  "mcpServers": {
    "console-automation": {
      "command": "npx",
      "args": ["@mcp/console-automation"],
      "env": {
        "LOG_LEVEL": "info"
      }
    }
  }
}

Who it's for

Agents and developers who need to drive real terminal workflows programmatically - running dev servers, executing tests, connecting to remote machines via SSH, monitoring long background jobs - with the same reliability Playwright brings to browser automation - the project's own usage examples span running a dev server while watching for errors, executing automated tests with output validation, connecting to remote servers over SSH, monitoring system metrics with alerts, and running long background tasks with priority queuing.

Source README

A production-ready MCP server that enables AI assistants to fully interact with console applications, monitor output, detect errors, and automate terminal workflows - works similarly to how Playwright works for web browsers.

Installation

Windows PowerShell

git clone https://github.com/ooples/console-automation-mcp.git
cd console-automation-mcp
.\install.ps1 -Target claude

macOS/Linux

git clone https://github.com/ooples/console-automation-mcp.git
cd console-automation-mcp
chmod +x install.sh
./install.sh --target claude

Manual Installation

git clone https://github.com/ooples/console-automation-mcp.git
cd console-automation-mcp
npm install --production
npm run build

NPX

npx @mcp/console-automation

Configuration

Claude Desktop

{
  "mcpServers": {
    "console-automation": {
      "command": "npx",
      "args": ["@mcp/console-automation"],
      "env": {
        "LOG_LEVEL": "info"
      }
    }
  }
}

Available Tools

Tool Description
console_create_session Create local or SSH console sessions
console_send_input Send text input to sessions
console_send_key Send special keys (Enter, Ctrl+C, etc.)
console_get_output Get filtered/paginated output with advanced search
console_get_stream Stream output from long-running processes
console_wait_for_output Wait for specific patterns
console_stop_session Stop sessions
console_list_sessions List all active sessions
console_cleanup_sessions Clean up inactive sessions
console_execute_command Execute commands with output capture
console_detect_errors Analyze output for errors
console_get_resource_usage Get system resource statistics
console_clear_output Clear output buffers
console_get_session_state Get session execution state
console_get_command_history View command history

Capabilities

  • Complete terminal management: create and manage up to 50 concurrent console sessions
  • Multi-protocol support: local shells (cmd, PowerShell, pwsh, bash, zsh, sh) and remote SSH connections
  • Interactive input: send text input and special key sequences (Enter, Tab, Ctrl+C, etc.)
  • Real-time output monitoring: capture, filter, and analyze console output with advanced search
  • Stream support: efficient streaming for long-running processes with pattern matching
  • Automatic error detection: built-in patterns for detecting errors, exceptions, and stack traces across multiple languages
  • Cross-platform: works on Windows, macOS, and Linux without native dependencies
  • Full SSH support: password and key-based authentication with passphrase support
  • Connection profiles: save and reuse SSH configurations for quick access
  • Automated test cases: built-in validation tools for verifying console output

Environment Variables

Optional

  • LOG_LEVEL - Set logging level (e.g., info, debug, error)

Usage Examples

Run a development server and monitor for errors
Execute automated tests with output validation
Connect to remote servers via SSH and execute commands
Monitor system metrics and configure alerts
Execute long-running background tasks with priority queuing

Notes

This is a production-ready server that requires no native code compilation. It supports up to 50 concurrent console sessions and includes comprehensive error detection patterns for many programming languages. The server provides 40 tools organized into 6 categories: session management, command execution, monitoring and alerts, profile management, background tasks, and test automation.

FAQ

Common questions

Discussion

Questions & comments · 0

Sign In Sign in to leave a comment.