Tabby MCP Server

A Tabby Terminal plugin that exposes your active terminal sessions through the Model Context Protocol (MCP). It lets MCP-compatible AI clients discover terminal tabs, execute commands, read terminal buffers, and retrieve long command output.

Tabby stays the terminal UI. Your AI client connects to Tabby through MCP.

Highlights

• MCP server inside Tabby — exposes an SSE endpoint at http://localhost:3001/sse
• Terminal session discovery — list local and SSH-backed Tabby terminal sessions
• Command execution — run commands in a selected Tabby terminal tab
• Robust output capture — simple marker protocol with exit-code parsing
• Terminal buffer access — read visible/history buffer ranges from a tab
• Long output pagination — retrieve full command output by outputId
• Pair programming mode — optional confirmation dialogs and user feedback
• Docker-based build — reproducible local plugin builds for Tabby

Demo

Table of Contents

• Requirements
• Installation
• Quick Start
• Connecting MCP Clients
  • SSE clients
  • Claude Code
  • Codex / OpenAI Codex CLI
• Tools
• Configuration
• Development
• License

Requirements

• Tabby Terminal installed and running
• Docker, for local builds
• macOS for the provided install script path
• An MCP-compatible client with SSE support, such as Claude Code, Cursor, Windsurf, Codex, or another SSE-capable MCP client

Installation

Option 1: Tabby Plugin Store

1. Open Tabby
2. Go to Settings → Plugins
3. Install Tabby MCP
4. Restart Tabby
5. Open Settings → Plugins → MCP and confirm the server configuration

Option 2: Local Docker Build

git clone https://github.com/thuanpham582002/tabby-mcp-server.git
cd tabby-mcp-server

make build-dist
bash scripts/copy_to_plugin_folder.sh

The install script copies the plugin to:

~/Library/Application Support/tabby/plugins/node_modules/tabby-mcp

Restart Tabby after installing or updating the plugin.

If your local Tabby installation requires bundled plugin dependencies, build the full package:

make build-dist-with-deps
bash scripts/copy_to_plugin_folder.sh

Quick Start

1. Start or restart Tabby
2. Open at least one terminal tab
3. Verify the MCP server is running:

curl http://localhost:3001/health
# OK

4. List Tabby terminal sessions:

curl -X POST http://localhost:3001/api/tool/get_ssh_session_list \
  -H 'Content-Type: application/json' \
  -d '{}'

5. Execute a command in a session:

curl -X POST http://localhost:3001/api/tool/exec_command \
  -H 'Content-Type: application/json' \
  -d '{"command":"pwd","tabId":"0"}'

Connecting MCP Clients

Tabby-MCP provides:

SSE endpoint:    http://localhost:3001/sse
Health endpoint: http://localhost:3001/health
HTTP test API:   http://localhost:3001/api/tool/<tool-name>

The Tabby plugin must be running before clients can connect.

SSE clients

Use this configuration for clients that support SSE MCP servers directly:

{
  "mcpServers": {
    "tabby-mcp": {
      "type": "sse",
      "url": "http://localhost:3001/sse"
    }
  }
}

For Cursor-style clients, place it in the MCP config file, for example:

~/.cursor/mcp.json

Claude Code

If your Claude Code version supports SSE MCP servers:

claude mcp add --transport sse tabby-mcp http://localhost:3001/sse

If your setup uses JSON config, use the SSE clients configuration.

Codex / OpenAI Codex CLI

Use the SSE MCP server configuration supported by your Codex client:

{
  "mcpServers": {
    "tabby-mcp": {
      "type": "sse",
      "url": "http://localhost:3001/sse"
    }
  }
}

For TOML-based configs, map the same SSE URL using your client's supported SSE MCP syntax.

Tools

Tool	Description	Parameters
get_ssh_session_list	List available Tabby terminal sessions	none
exec_command	Execute a shell command in a terminal tab	command, tabId, commandExplanation
get_terminal_buffer	Read terminal buffer content	tabId, startLine, endLine
get_command_output	Retrieve full/paginated command output	outputId, startLine, maxLines

Configuration

Default plugin configuration:

{
  "mcp": {
    "enabled": true,
    "startOnBoot": true,
    "port": 3001,
    "serverUrl": "http://localhost:3001",
    "enableDebugLogging": true,
    "pairProgrammingMode": {
      "enabled": true,
      "showConfirmationDialog": true,
      "autoFocusTerminal": true
    }
  }
}

Configure these options in Tabby under Settings → Plugins → MCP.

Pair Programming Mode

Pair Programming Mode adds safety prompts when an AI client executes commands:

• confirmation before command execution
• optional terminal auto-focus
• command rejection with feedback
• command result dialog and history tracking

Development

Clone and build:

git clone https://github.com/thuanpham582002/tabby-mcp-server.git
cd tabby-mcp-server
make build-dist

Install into local Tabby:

bash scripts/copy_to_plugin_folder.sh

Restart Tabby and verify:

curl http://localhost:3001/health

Build targets

make build-dist            # Build dist only
make build-dist-with-deps  # Build dist and copy node_modules
make help                  # Show available targets

License

MIT — see LICENSE.

---

Made with ❤️ by Pham Tien Thuan