Skip to content
Back to search

tabby-mcp-server

MCP server for control Tabby terminal

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/thuanpham582002--tabby-mcp-server/badge.svg)](/listings/thuanpham582002--tabby-mcp-server)

HTML

<a href="/listings/thuanpham582002--tabby-mcp-server"><img src="/api/listings/thuanpham582002--tabby-mcp-server/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

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

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 255 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # Tabby MCP Server
  2. [![npm version](https://img.shields.io/npm/v/tabby-mcp.svg)](https://www.npmjs.com/package/tabby-mcp)
  3. [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  4. [![GitHub issues](https://img.shields.io/github/issues/thuanpham582002/tabby-mcp-server.svg)](https://github.com/thuanpham582002/tabby-mcp-server/issues)
  5. [![GitHub stars](https://img.shields.io/github/stars/thuanpham582002/tabby-mcp-server.svg)](https://github.com/thuanpham582002/tabby-mcp-server/stargazers)
  6. A [Tabby Terminal](https://github.com/Eugeny/tabby) plugin that exposes your active terminal sessions through the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/). It lets MCP-compatible AI clients discover terminal tabs, execute commands, read terminal buffers, and retrieve long command output.
  7. > Tabby stays the terminal UI. Your AI client connects to Tabby through MCP.
  8. ## Highlights
  9. - **MCP server inside Tabby** — exposes an SSE endpoint at `http://localhost:3001/sse`
  10. - **Terminal session discovery** — list local and SSH-backed Tabby terminal sessions
  11. - **Command execution** — run commands in a selected Tabby terminal tab
  12. - **Robust output capture** — simple marker protocol with exit-code parsing
  13. - **Terminal buffer access** — read visible/history buffer ranges from a tab
  14. - **Long output pagination** — retrieve full command output by `outputId`
  15. - **Pair programming mode** — optional confirmation dialogs and user feedback
  16. - **Docker-based build** — reproducible local plugin builds for Tabby
  17. ## Demo
  18. [![Tabby MCP Plugin - AI Terminal Integration Demo](https://img.youtube.com/vi/uFWBGiD4x9c/0.jpg)](https://youtu.be/uFWBGiD4x9c)
  19. ## Table of Contents
  20. - [Requirements](#requirements)
  21. - [Installation](#installation)
  22. - [Quick Start](#quick-start)
  23. - [Connecting MCP Clients](#connecting-mcp-clients)
  24. - [SSE clients](#sse-clients)
  25. - [Claude Code](#claude-code)
  26. - [Codex / OpenAI Codex CLI](#codex--openai-codex-cli)
  27. - [Tools](#tools)
  28. - [Configuration](#configuration)
  29. - [Development](#development)
  30. - [License](#license)
  31. ## Requirements
  32. - Tabby Terminal installed and running
  33. - Docker, for local builds
  34. - macOS for the provided install script path
  35. - An MCP-compatible client with SSE support, such as Claude Code, Cursor, Windsurf, Codex, or another SSE-capable MCP client
  36. ## Installation
  37. ### Option 1: Tabby Plugin Store
  38. 1. Open Tabby
  39. 2. Go to **Settings → Plugins**
  40. 3. Install **Tabby MCP**
  41. 4. Restart Tabby
  42. 5. Open **Settings → Plugins → MCP** and confirm the server configuration
  43. ### Option 2: Local Docker Build
  44. ```bash
  45. git clone https://github.com/thuanpham582002/tabby-mcp-server.git
  46. cd tabby-mcp-server
  47. make build-dist
  48. bash scripts/copy_to_plugin_folder.sh
  49. ```
  50. The install script copies the plugin to:
  51. ```text
  52. ~/Library/Application Support/tabby/plugins/node_modules/tabby-mcp
  53. ```
  54. Restart Tabby after installing or updating the plugin.
  55. If your local Tabby installation requires bundled plugin dependencies, build the full package:
  56. ```bash
  57. make build-dist-with-deps
  58. bash scripts/copy_to_plugin_folder.sh
  59. ```
  60. ## Quick Start
  61. 1. Start or restart Tabby
  62. 2. Open at least one terminal tab
  63. 3. Verify the MCP server is running:
  64. ```bash
  65. curl http://localhost:3001/health
  66. # OK
  67. ```
  68. 4. List Tabby terminal sessions:
  69. ```bash
  70. curl -X POST http://localhost:3001/api/tool/get_ssh_session_list \
  71. -H 'Content-Type: application/json' \
  72. -d '{}'
  73. ```
  74. 5. Execute a command in a session:
  75. ```bash
  76. curl -X POST http://localhost:3001/api/tool/exec_command \
  77. -H 'Content-Type: application/json' \
  78. -d '{"command":"pwd","tabId":"0"}'
  79. ```
  80. ## Connecting MCP Clients
  81. Tabby-MCP provides:
  82. ```text
  83. SSE endpoint: http://localhost:3001/sse
  84. Health endpoint: http://localhost:3001/health
  85. HTTP test API: http://localhost:3001/api/tool/<tool-name>
  86. ```
  87. The Tabby plugin must be running before clients can connect.
  88. ### SSE clients
  89. Use this configuration for clients that support SSE MCP servers directly:
  90. ```json
  91. {
  92. "mcpServers": {
  93. "tabby-mcp": {
  94. "type": "sse",
  95. "url": "http://localhost:3001/sse"
  96. }
  97. }
  98. }
  99. ```
  100. For Cursor-style clients, place it in the MCP config file, for example:
  101. ```text
  102. ~/.cursor/mcp.json
  103. ```
  104. ### Claude Code
  105. If your Claude Code version supports SSE MCP servers:
  106. ```bash
  107. claude mcp add --transport sse tabby-mcp http://localhost:3001/sse
  108. ```
  109. If your setup uses JSON config, use the [SSE clients](#sse-clients) configuration.
  110. ### Codex / OpenAI Codex CLI
  111. Use the SSE MCP server configuration supported by your Codex client:
  112. ```json
  113. {
  114. "mcpServers": {
  115. "tabby-mcp": {
  116. "type": "sse",
  117. "url": "http://localhost:3001/sse"
  118. }
  119. }
  120. }
  121. ```
  122. For TOML-based configs, map the same SSE URL using your client's supported SSE MCP syntax.
  123. ## Tools
  124. | Tool | Description | Parameters |
  125. | --- | --- | --- |
  126. | `get_ssh_session_list` | List available Tabby terminal sessions | none |
  127. | `exec_command` | Execute a shell command in a terminal tab | `command`, `tabId`, `commandExplanation` |
  128. | `get_terminal_buffer` | Read terminal buffer content | `tabId`, `startLine`, `endLine` |
  129. | `get_command_output` | Retrieve full/paginated command output | `outputId`, `startLine`, `maxLines` |
  130. ## Configuration
  131. Default plugin configuration:
  132. ```json
  133. {
  134. "mcp": {
  135. "enabled": true,
  136. "startOnBoot": true,
  137. "port": 3001,
  138. "listenHost": "127.0.0.1",
  139. "serverUrl": "http://localhost:3001",
  140. "enableDebugLogging": true,
  141. "pairProgrammingMode": {
  142. "enabled": true,
  143. "showConfirmationDialog": true,
  144. "autoFocusTerminal": true
  145. }
  146. }
  147. }
  148. ```
  149. Configure these options in Tabby under **Settings → Plugins → MCP**.
  150. To accept connections from other machines or environments such as WSL, set
  151. `listenHost` to `0.0.0.0` in the MCP settings. This makes the server reachable
  152. over the network; use an address reachable from your MCP client in its server
  153. URL and apply any needed firewall restrictions.
  154. ### Pair Programming Mode
  155. Pair Programming Mode adds safety prompts when an AI client executes commands:
  156. - confirmation before command execution
  157. - optional terminal auto-focus
  158. - command rejection with feedback
  159. - command result dialog and history tracking
  160. ## Development
  161. Clone and build:
  162. ```bash
  163. git clone https://github.com/thuanpham582002/tabby-mcp-server.git
  164. cd tabby-mcp-server
  165. make build-dist
  166. ```
  167. Install into local Tabby:
  168. ```bash
  169. bash scripts/copy_to_plugin_folder.sh
  170. ```
  171. Restart Tabby and verify:
  172. ```bash
  173. curl http://localhost:3001/health
  174. ```
  175. ### Build targets
  176. ```bash
  177. make build-dist # Build dist only
  178. make build-dist-with-deps # Build dist and copy node_modules
  179. make help # Show available targets
  180. ```
  181. ## License
  182. MIT — see [LICENSE](LICENSE).
  183. ---
  184. <p align="center">
  185. Made with ❤️ by <a href="https://github.com/thuanpham582002">Pham Tien Thuan</a>
  186. </p>

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.