Content
# Persistent Terminal MCP Server
[English](README.en.md)
A powerful Model Context Protocol (MCP) server, implemented in TypeScript and based on [`node-pty`](https://github.com/microsoft/node-pty) for persistent terminal session management. Terminal commands will continue to run even if the client disconnects, making it particularly suitable for AI assistants like Claude, Cursor, and Cline to perform long-running tasks.
YouTube video link: https://youtu.be/nfLi1IZxhJs
Bilibili video link: https://www.bilibili.com/video/BV14ksPzqEbM/
Windows configuration MCP video tutorial link: https://youtu.be/WYEKwTQCAnc
## ✨ Core Features
### 🔥 Persistent Terminal Sessions
- **Long-running**: Create, reuse, and manage long-running Shell sessions
- **Resume after disconnection**: The terminal continues to run after the client disconnects, allowing operations to continue upon reconnection
- **Multi-session management**: Manage multiple independent terminal sessions simultaneously
- **Automatic cleanup**: Timeout sessions are automatically cleaned up to avoid resource leaks
### 🧠 Intelligent Output Management
- **Circular Buffer**: Configurable size (default 10,000 lines), automatically manages memory
- **Multiple Reading Modes**:
- `full`: Complete output
- `head`: Read only the first N lines
- `tail`: Read only the last N lines
- `head-tail`: Read both the beginning and the end simultaneously
- **Incremental Reading**: Use the `since` parameter to read only new content
- **Token Estimation**: Automatically estimates the number of tokens in the output, facilitating AI context control
### 🎨 Spinner Animation Compression
- **Automatic Detection**: Recognizes common progress animation characters (⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏, ◐◓◑◒, etc.)
- **Intelligent Throttling**: Reduces noise output from commands like `npm install`, `yarn`, `pnpm`, etc.
- **Key Information Retention**: Compresses animations while preserving real logs
- **Flexible Configuration**: Can be controlled via environment variables or parameters
### 🌐 Web Visualization Management Interface
- **Real-time Terminal**: Terminal rendering based on xterm.js, supporting full ANSI colors
- **WebSocket Push**: Terminal output displayed in real-time without the need for refresh
- **Interactive Operations**: Send commands and view output directly in the browser
- **Multi-instance Support**: Automatic port allocation, supporting multiple AI clients simultaneously
- **VS Code Style**: Dark theme with a clean and aesthetically pleasing interface design
### 🤖 Codex Automatic Bug Fixing
- **Fully Automated**: Integrates OpenAI Codex CLI to automatically fix code bugs
- **Documentation Driven**: AI descriptions are saved as MD documents, which Codex reads and fixes
- **Detailed Reports**: Generates complete repair reports, including before-and-after comparisons
- **Intelligent Waiting**: Automatically detects when Codex execution is complete, with a default timeout of 10 minutes
- **History**: All bug descriptions and repair reports are permanently stored in the docs/ directory
### 🔌 Multiple Integration Methods
- **MCP Protocol**: Natively supports clients such as Claude Desktop, Claude Code, Cursor, Cline, etc.
- **REST API**: Provides an HTTP interface for easy integration in non-MCP scenarios.
- **Strict Compatibility**: Fully complies with the MCP stdio protocol specification, ensuring clean and unpolluted stdout.
### 🛡️ Stability Assurance
- **Output Stability Detection**: The `wait_for_output` tool ensures complete output is captured
- **Interactive Application Support**: Perfectly supports interactive programs like vim, npm create, etc.
- **ANSI Escape Sequences**: Correctly handles terminal control characters
- **Error Recovery**: Automatic reconnection and exception handling mechanisms
## 🚀 Installation Method
### ✅ Quick Start (Recommended)
No installation required, simply use `npx` to start:
```bash
npx persistent-terminal-mcp
```
The REST version is also supported:
```bash
npx persistent-terminal-mcp-rest
```
### 📦 Integrating into Existing Projects
```bash
npm install persistent-terminal-mcp
```
After installation, you can import all core classes and types in your code:
```ts
import { PersistentTerminalMcpServer } from 'persistent-terminal-mcp';
```
### 🌐 Global Installation (Optional)
```bash
npm install --global persistent-terminal-mcp
persistent-terminal-mcp
```
## 🧪 Local Development
Suitable for scenarios where you want to modify the source code or debug in depth:
```bash
npm install # Install dependencies
npm run build # Compile TypeScript → dist/
npm start # Start the MCP server via stdio
```
During the development phase, you can also run the TypeScript source code directly:
```bash
npm run dev # MCP server (tsx)
npm run dev:rest # REST server (tsx)
```
### 🐞 Debug Mode
Enable debug logging (output to stderr, will not interfere with MCP communication):
```bash
MCP_DEBUG=true persistent-terminal-mcp
```
### 📚 Example Scripts
```bash
npm run example:basic # Basic operations: Create → Write → Read → Terminate
npm run example:smart # Smart reading: Demonstration of head/tail/head-tail modes
npm run example:spinner # Spinner compression feature demonstration
npm run example:webui # Web UI feature demonstration
npm run test:tools # Full validation of all MCP tools
npm run test:fixes # Regression testing of critical fixes
```
## ⚙️ MCP Client Configuration
### Claude Desktop
#### macOS / Linux
**Configuration File Location**: `~/Library/Application Support/Claude/claude_desktop_config.json`
Add the following content to the configuration file:
```json
{
"mcpServers": {
"persistent-terminal": {
"command": "npx",
"args": ["-y", "persistent-terminal-mcp"],
"env": {
"MAX_BUFFER_SIZE": "10000",
"SESSION_TIMEOUT": "86400000",
"COMPACT_ANIMATIONS": "true",
"ANIMATION_THROTTLE_MS": "100"
}
}
}
}
```
**Note**:
- The `-y` parameter will automatically confirm the download prompt from npx.
- If you have installed it globally (`npm install -g persistent-terminal-mcp`), you can change the `command` to `"persistent-terminal-mcp"` and remove `-y` from the `args`.
#### Windows
**Configuration File Location**: `%APPDATA%\Claude\claude_desktop_config.json`
```json
{
"mcpServers": {
"persistent-terminal": {
"command": "cmd",
"args": ["/c", "npx", "-y", "persistent-terminal-mcp"],
"env": {
"MAX_BUFFER_SIZE": "10000",
"SESSION_TIMEOUT": "86400000",
"COMPACT_ANIMATIONS": "true",
"ANIMATION_THROTTLE_MS": "100"
}
}
}
}
```
**Note**:
- Windows requires calling `npx` through `cmd /c`
- If installed globally, you can change `args` to `["/c", "persistent-terminal-mcp"]`
### Claude Code
#### macOS / Linux
Quickly add using the command line:
```bash
claude mcp add persistent-terminal \
--env MAX_BUFFER_SIZE=10000 \
--env SESSION_TIMEOUT=86400000 \
--env COMPACT_ANIMATIONS=true \
--env ANIMATION_THROTTLE_MS=100 \
-- npx -y persistent-terminal-mcp
```
**Or** edit the configuration file `~/.claude.json`:
```json
{
"mcpServers": {
"persistent-terminal": {
"command": "npx",
"args": ["-y", "persistent-terminal-mcp"],
"env": {
"MAX_BUFFER_SIZE": "10000",
"SESSION_TIMEOUT": "86400000",
"COMPACT_ANIMATIONS": "true",
"ANIMATION_THROTTLE_MS": "100"
}
}
}
}
```
#### Windows
> # ⚠️ **Attention Windows Users**
>
> ## **Claude Code** has a parameter parsing issue with the `claude mcp add` command on Windows
>
> ### **🚫 Command Line Usage Not Recommended**
>
> Please refer to the dedicated configuration document:
> ### 📖 [《Configuring persistent-terminal MCP on Windows》](docs/clients/claude-code-windows.md)
>
> This document provides two recommended solutions:
> - ✅ **Project-level Configuration** (recommended): Create a `.mcp.json` file in the project root directory
> - ✅ **Global Configuration**: Modify `~/.claude.json` using a Python script
### Cursor / Cline
The configuration method is similar to that of Claude Desktop. Please refer to the MCP configuration documentation for each client.
### Codex
#### macOS / Linux
Add the following configuration to the `.codex/config.toml` file:
```toml
# MCP Server Configuration (TOML Format)
# Configuration for persistent-terminal MCP Server
[mcp_servers.persistent-terminal]
command = "npx"
args = ["-y", "persistent-terminal-mcp"]
[mcp_servers.persistent-terminal.env]
MAX_BUFFER_SIZE = "10000"
SESSION_TIMEOUT = "86400000"
COMPACT_ANIMATIONS = "true"
ANIMATION_THROTTLE_MS = "100"
#### Windows
Add the following configuration to the `.codex/config.toml` file:
```toml
# MCP Server Configuration (TOML Format)
# Configuration for persistent-terminal MCP Server
[mcp_servers.persistent-terminal]
command = "cmd"
args = ["/c", "npx", "-y", "persistent-terminal-mcp"]
[mcp_servers.persistent-terminal.env]
MAX_BUFFER_SIZE = "10000"
SESSION_TIMEOUT = "86400000"
COMPACT_ANIMATIONS = "true"
ANIMATION_THROTTLE_MS = "100"
```
**Note**: Windows requires `cmd /c` to invoke `npx`
---
### Environment Variable Description
| Variable | Description | Default Value |
|----------|-------------|---------------|
| `MAX_BUFFER_SIZE` | Maximum number of lines in the buffer | 10000 |
| `SESSION_TIMEOUT` | Session timeout duration (milliseconds) | 86400000 (24 hours) |
| `COMPACT_ANIMATIONS` | Whether to enable Spinner compression | true |
| `ANIMATION_THROTTLE_MS` | Animation throttle time (milliseconds) | 100 |
| `MCP_DEBUG` | Whether to enable debug logging | false |
## 🧱 Programmatic Use of TypeScript
```ts
import {
PersistentTerminalMcpServer,
TerminalManager,
RestApiServer
} from 'persistent-terminal-mcp';
const manager = new TerminalManager();
const rest = new RestApiServer(manager);
await rest.start(3001);
const mcpServer = new PersistentTerminalMcpServer();
const server = mcpServer.getServer();
await server.connect(/* custom transport */);
```
All core classes and types can be accessed from the root entry of the package. For more details, please refer to `src/index.ts`.
## 🛠️ MCP Tool Overview
| Tool | Function | Main Parameters |
|------|----------|-----------------|
| `create_terminal` | Create a persistent terminal session | `shell`, `cwd`, `env`, `cols`, `rows` |
| `create_terminal_basic` | Simplified creation entry | `shell`, `cwd` |
| `write_terminal` | Write commands to the terminal | `terminalId`, `input`, `appendNewline` |
| `read_terminal` | Read buffered output | `terminalId`, `mode`, `since`, `stripSpinner` |
| `wait_for_output` | Wait for output to stabilize | `terminalId`, `timeout`, `stableTime` |
| `get_terminal_stats` | View statistics | `terminalId` |
| `list_terminals` | List all active terminals | None |
| `kill_terminal` | Terminate session | `terminalId`, `signal` |
| `open_terminal_ui` | Open the web management interface | `port`, `autoOpen` |
| `fix_bug_with_codex` 🆕 | Automatically fix bugs using Codex | `description`, `cwd`, `timeout` |
### Tool Details
#### `create_terminal` - Create Terminal
Create a new persistent terminal session.
**Parameters**:
- `shell` (optional): Shell type, such as `/bin/bash`, `/bin/zsh`
- `cwd` (optional): Working directory
- `env` (optional): Environment variable object
- `cols` (optional): Number of terminal columns, default is 80
- `rows` (optional): Number of terminal rows, default is 24
**Returns**:
- `terminalId`: Terminal ID
- `status`: Status
- `pid`: Process ID
- `shell`: Shell type
- `cwd`: Working directory
#### `write_terminal` - Write Command
Send commands or input to the terminal.
**Parameters**:
- `terminalId`: Terminal ID
- `input`: Content to be sent
- `appendNewline` (optional): Whether to automatically add a newline character, default is true
**Tip**: By default, a newline character is automatically added to execute the command. If you need to send raw control characters (such as arrow keys), please set `appendNewline: false`.
#### `read_terminal` - Read Output
Read the buffered output of the terminal, supporting various smart truncation modes.
**Parameters**:
- `terminalId`: Terminal ID
- `mode` (optional): Read mode
- `full`: Full output (default)
- `head`: Read only the beginning
- `tail`: Read only the end
- `head-tail`: Read both the beginning and the end
- `since` (optional): Start reading from line N (incremental reading)
- `maxLines` (optional): Maximum number of lines, default is 1000
- `headLines` (optional): Number of lines in head mode, default is 50
- `tailLines` (optional): Number of lines in tail mode, default is 50
- `stripSpinner` (optional): Whether to compress the Spinner animation
**Returns**:
- `output`: Output content
- `totalLines`: Total number of lines
- `lineRange`: Actual range of returned lines
- `estimatedTokens`: Estimated number of tokens
- `truncated`: Whether it was truncated
- `spinnerCompacted`: Whether the Spinner was compressed
#### `wait_for_output` - Wait for Output Stability
Wait for the terminal output to stabilize before reading, ensuring complete output is obtained.
**Parameters**:
- `terminalId`: Terminal ID
- `timeout` (optional): Maximum wait time (milliseconds), default is 5000
- `stableTime` (optional): Stability time (milliseconds), default is 500
**Usage Scenarios**:
- Ensure complete output is obtained after executing a command
- Wait for interactive applications to finish starting up
#### `fix_bug_with_codex` 🆕 - Automatic Bug Fixing
Use the OpenAI Codex CLI to automatically analyze and fix bugs in the code.
**Parameters**:
- `description` (required): A detailed bug description, which must include:
- Problem symptoms (specific erroneous behavior)
- Expected behavior (how it should work)
- Problem location (file path, line number, function name)
- Relevant code (problematic code snippet)
- Root cause (why this issue occurs)
- Suggested fix (how to fix it)
- Impact scope (what else it may affect)
- Related files (all relevant file paths)
- Test cases (how to verify if the fix is effective)
- Context information (background information that helps understand the issue)
- `cwd` (optional): Working directory, defaults to the current directory
- `timeout` (optional): Timeout duration (milliseconds), default is 600000 (10 minutes)
**Returns**:
- `terminalId`: The terminal ID executing Codex
- `reportPath`: Path to the fix report
- `reportExists`: Whether the report exists
- `workingDir`: Working directory
- `executionTime`: Execution time (seconds)
- `timedOut`: Whether it timed out
- `output`: Terminal output
- `reportPreview`: Report preview
**Workflow**:
1. AI provides a detailed bug description
2. The tool saves the description to `docs/codex-bug-description-TIMESTAMP.md`
3. Codex reads the document and analyzes the issue
4. Codex fixes the bug and generates a report `docs/codex-fix-TIMESTAMP.md`
5. AI reads the report and summarizes it for the user
**Important Notes**:
- ⚠️ This tool has full system access (`danger-full-access`)
- ⚠️ Codex can modify any files, it is recommended to use it in a Git repository
- ✅ Use English descriptions only (to avoid UTF-8 encoding issues)
- ✅ The more detailed the description, the higher the quality of the fix
**Example**:
```javascript
fix_bug_with_codex({
description: `Username validation bug in auth.js file.
PROBLEM:
- File: src/auth/login.ts, line 45
- Code: const usernameRegex = /^[a-zA-Z0-9]{3,20}$/
- Symptom: Username 'user_name' is rejected with 'Invalid username' error
- Expected: Should accept usernames with underscores and hyphens
ROOT CAUSE:
- Regex [a-zA-Z0-9] only allows letters and numbers
- Missing support for underscore and hyphen characters
SUGGESTED FIX:
- Change regex to: /^[a-zA-Z0-9_-]{3,20}$/
VERIFICATION:
- Run: npm test
- Expected: all tests pass`,
cwd: '/path/to/project',
timeout: 600000
})
```
**Detailed Documentation**:
- [Codex Bug Fix Tool Function Documentation](docs/features/CODEX_BUG_FIX_TOOL.md)
- [Codex Bug Fix Tool Test Report](docs/features/CODEX_BUG_FIX_TEST_REPORT.md)
> **💡 Tip**: The Codex CLI requires OpenAI API access. If you are in a region with access issues, consider using the [Codex CLI mirror service](https://www.codex-cli.top) (¥99/month, daily $90 quota) to make AI programming smoother.
#### `open_terminal_ui` - Open Web Management Interface
Launch a browser-based visual terminal management interface.
**Parameters**:
- `port` (optional): Port number, defaults to automatically searching starting from 3002
- `autoOpen` (optional): Whether to automatically open the browser, defaults to true
**Returns**:
- `url`: Web UI address
- `port`: Actual port used
- `mode`: Launch mode (new/existing)
- `autoOpened`: Whether the browser was automatically opened
#### `fix_bug_with_codex` 🆕 - Automatically Fix Bugs Using Codex
Invoke the OpenAI Codex CLI to automatically analyze and fix bugs in the code, generating a detailed repair report.
**⚠️ Important Note**:
- This tool operates in **full permission mode** (`--sandbox danger-full-access --ask-for-approval never`)
- Codex has complete control over the codebase, use with caution
- It is recommended to back up the code or use version control before usage
**Parameters**:
- `description` (required): **Detailed** bug description, must include:
- Problem manifestation (specific error behavior)
- Expected behavior (how it should work)
- Problem location (file path, line number)
- Relevant code snippets
- Root cause (if known)
- Fix suggestions (if any)
- Scope of impact (potentially affected functionalities)
- Related files (all relevant file paths)
- Test cases (how to verify the fix)
- Context information (background information)
- `cwd` (optional): Working directory, defaults to the current directory
- `timeout` (optional): Timeout duration (milliseconds), defaults to 600000 (10 minutes)
**Returns**:
- `terminalId`: Terminal ID where Codex was executed
- `reportPath`: Path to the repair report (`docs/codex-fix-TIMESTAMP.md`)
- `reportExists`: Whether the report was successfully generated
- `executionTime`: Execution time
- `output`: Terminal output from Codex
**Workflow**:
1. The AI assistant collects detailed bug information
2. Calls this tool, passing in the detailed description
3. Codex analyzes the issue and fixes the code
4. Codex generates a detailed report in the `docs/` directory
5. The AI assistant reads the report and informs the user
**Report Content**:
- Problem description
- List of modified files
- Specific changes for each file (before/after comparison)
- Explanation of the reasons for changes
- Testing suggestions
- Notes
**Usage Example**:
```
User: There is a bug in the login feature, username validation always fails
AI Assistant:
1. [Review relevant files to understand the issue]
2. [Invoke fix_bug_with_codex]
{
"description": "There is a bug in the username validation of the login feature, specifically:
1. Problem manifestation: User is rejected when entering 'user_name'
2. Expected behavior: Should accept usernames containing underscores
3. Problem location: src/auth/login.ts line 45
4. Relevant code: const usernameRegex = /^[a-zA-Z0-9]{3,20}$/
5. Root cause: The regular expression does not allow underscores
..."
}
3. [Wait for Codex to complete]
4. [Read the report] view("docs/codex-fix-2025-10-18T00-35-12.md")
5. [Report the fix results to the user]
```
**Prerequisites**:
- Codex CLI installed: `npm install -g @openai/codex-cli`
- Codex authentication configured
- The project contains a `docs/` directory
**Best Practices**:
- Provide as detailed a bug description as possible (the more detailed the description, the higher the quality of the fix)
- Review relevant files to understand the issue before invoking
- Always run tests to validate after fixing
- Check the generated report to understand specific changes
- Use version control for easy rollback
## 🌐 Web Management Interface
### Features
- 📊 **Terminal List**: View the status, PID, Shell, working directory, and other information of all terminals
- 🖥️ **Real-time Terminal**: Render terminal output using xterm.js, supporting ANSI colors
- ⚡ **Real-time Updates**: WebSocket push, terminal output displayed in real-time
- ⌨️ **Interactive Operations**: Send commands directly in the browser
- 🎨 **VS Code Style**: Dark theme, simple and elegant
- 🔄 **Automatic Port**: Supports multiple instances, automatically avoids port conflicts
### Quick Start
Say in Claude or other MCP clients:
```
Please open the terminal management interface
```
Or directly run the test script:
```bash
npm run test:webui
```
For detailed usage instructions, see [Web UI Usage Guide](docs/guides/WEB_UI_USAGE.md).
## 🔌 REST API (Optional)
If an HTTP interface is needed, you can start the REST version:
```bash
npx persistent-terminal-mcp-rest
```
The server listens on port `3001` by default (configurable), and the endpoints correspond one-to-one with the MCP tool:
| Endpoint | Method | Description |
|----------|--------|-------------|
| `/api/terminals` | POST | Create terminal |
| `/api/terminals` | GET | List all terminals |
| `/api/terminals/:id` | GET | Get terminal details |
| `/api/terminals/:id` | DELETE | Terminate terminal |
| `/api/terminals/:id/input` | POST | Send command |
| `/api/terminals/:id/output` | GET | Read output |
| `/api/terminals/:id/stats` | GET | Get statistics |
## 📁 Project Structure
```
persistent-terminal-mcp/
├── src/ # TypeScript source code
│ ├── index.ts # MCP server entry point
│ ├── mcp-server.ts # MCP server implementation
│ ├── terminal-manager.ts # Terminal manager
│ ├── output-buffer.ts # Output buffer
│ ├── web-ui-manager.ts # Web UI manager
│ ├── web-ui-server.ts # Web UI server
│ ├── rest-server.ts # REST API server
│ ├── types.ts # Type definitions
│ ├── __tests__/ # Unit tests
│ └── examples/ # Example scripts
├── dist/ # Compiled JavaScript
├── public/ # Web UI static files
├── docs/ # Documentation
│ ├── guides/ # Usage guides
│ ├── reference/ # Technical reference
│ ├── clients/ # Client configuration
│ └── zh/ # Chinese documentation
├── tests/ # Test suite
│ └── integration/ # Integration tests
└── scripts/ # Helper scripts
```
## 📚 Document Navigation
### Quick Access
- 📖 [Full Documentation Index](docs/README.md)
- 🚨 [Fix Documentation Index](docs/reference/fixes/README.md)
- 🧪 [Integration Testing Instructions](tests/integration/README.md)
- 🌐 [Web UI Usage Guide](docs/guides/WEB_UI_USAGE.md)
### By Category
- **User Guides**: [Usage Instructions](docs/guides/usage.md) | [Troubleshooting](docs/guides/troubleshooting.md) | [MCP Configuration](docs/guides/mcp-config.md)
- **Technical Reference**: [Technical Details](docs/reference/technical-details.md) | [Tools Summary](docs/reference/tools-summary.md)
- **Fix Documentation**: [Stdio Fix](docs/reference/fixes/STDIO_FIX.md) | [Cursor Fix](docs/reference/fixes/CURSOR_FIX_SUMMARY.md) | [Terminal Fixes](docs/reference/fixes/TERMINAL_FIXES.md)
- **Client Configuration**: [Claude Desktop/Code](docs/clients/claude-code-setup.md)
## 🔍 Important Notes
### Stdio Purity
This MCP Server strictly adheres to the MCP protocol, ensuring that stdout contains only JSON-RPC messages, while all logs are output to stderr. This guarantees full compatibility with strict clients like Cursor. For more details, see the [Stdio Fix Documentation](docs/reference/fixes/STDIO_FIX.md).
### Cursor Compatibility
Fully compatible with Cursor and other MCP clients that require strict JSON-RPC communication. For quick setup, see the [Quick Fix Guide](docs/reference/fixes/QUICK_FIX_GUIDE.md).
### Terminal Interaction
Supports interactive applications (such as vim, npm create, etc.) and correctly handles ANSI escape sequences. For more details, see the [Terminal Fixes Documentation](docs/reference/fixes/TERMINAL_FIXES.md).
### Output Stability
Use the `wait_for_output` tool to ensure complete output is obtained after command execution, avoiding the reading of incomplete data.
## 🧪 Testing
### Running Tests
```bash
npm test # Run all unit tests
npm run test:integration # Run all integration tests
npm run test:all # Run all tests
```
### Integration Testing
```bash
npm run test:integration:stdio # Stdio purity test
npm run test:integration:cursor # Cursor scenario test
npm run test:integration:terminal # Terminal functionality test
```
## 🤝 Contribution Guidelines
We welcome you to submit Issues or PRs! For detailed processes and coding standards, please refer to [CONTRIBUTING.md](CONTRIBUTING.md).
### Contribution Guidelines
1. Fork this repository
2. Create a feature branch (`git checkout -b feature/AmazingFeature`)
3. Commit your changes (`git commit -m 'Add some AmazingFeature'`)
4. Push to the branch (`git push origin feature/AmazingFeature`)
5. Open a Pull Request
## 📄 Open Source License
This project is licensed under the [MIT License](LICENSE).
## 🙏 Acknowledgments
- [node-pty](https://github.com/microsoft/node-pty) - A powerful PTY library
- [Model Context Protocol](https://modelcontextprotocol.io/) - MCP protocol specification
- [xterm.js](https://xtermjs.org/) - An excellent terminal emulator
## 📞 Support
- 📖 View the [Documentation](docs/README.md)
- 🐛 Submit an [Issue](https://github.com/yourusername/node-pty/issues)
- 💬 Join the [Discussion](https://github.com/yourusername/node-pty/discussions)
---
**Last Updated**: 2025-10-08
**Version**: 1.0.1
MCP Store
