# CAMEL Terminal Toolkit MCP Server
This is a standalone MCP (Model Context Protocol) server that exports the CAMEL Terminal Toolkit functionality. It allows LLM clients to execute terminal commands safely through the MCP protocol.
## Features
- **Shell Execution**: Execute shell commands in managed sessions
- **Session Management**: Create and manage multiple shell sessions
- **Safe Mode**: Restrict dangerous operations and enforce working directory boundaries
- **Interactive Support**: Support for interactive commands (Linux/macOS only)
- **Process Management**: Control running processes (view, wait, write input, kill)
- **Human Takeover**: Request human assistance when needed
## Installation
### Option 1: Using uvx (Recommended)
The easiest way to use this MCP server is with `uvx`, which will automatically install and run it:
```bash
uvx terminal-toolkit-mcp
```
### Option 2: Using pip
```bash
pip install terminal-toolkit-mcp
```
### Option 3: Development Installation
```bash
git clone https://github.com/camel-ai/terminal-toolkit-mcp.git
cd terminal-toolkit-mcp
pip install -e .
```
## Usage
### As an MCP Server
Start the server with stdio transport:
```bash
terminal-toolkit-mcp
```
### Command Line Options
- `--working-directory PATH`: Set the working directory for operations
- `--timeout SECONDS`: Set timeout for operations (default: 20.0)
- `--safe-mode` / `--no-safe-mode`: Enable/disable safe mode (default: enabled)
- `--interactive`: Enable interactive mode for commands requiring input
- `--transport {stdio}`: Set transport type (currently only stdio supported)
### Example
```bash
# Start with custom working directory and increased timeout
terminal-toolkit-mcp --working-directory /tmp/workspace --timeout 60.0
# Start with safe mode disabled (not recommended)
terminal-toolkit-mcp --no-safe-mode
```
## Available Tools
The server exposes the following tools through MCP:
1. **shell_exec(id, command)**: Execute a shell command in a session
2. **shell_view(id)**: View the output history of a session
3. **shell_wait(id, seconds)**: Wait for a running command to complete
4. **shell_write_to_process(id, input, press_enter)**: Send input to a running process
5. **shell_kill_process(id)**: Terminate a running process
6. **ask_user_for_help(id)**: Request human assistance
## MCP Client Configuration
To use this server with MCP clients, you need to configure your client to connect to the terminal toolkit server. Here are examples for different scenarios:
### For Claude Desktop
Add this configuration to your Claude Desktop settings (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):
```json
{
"mcpServers": {
"terminal-toolkit": {
"command": "uvx",
"args": ["terminal-toolkit-mcp"]
}
}
}
```
### For CAMEL Framework
#### Option 1: Using MCPClient (Direct Connection)
```python
import asyncio
from camel.utils.mcp_client import MCPClient
async def main():
config = {
"command": "uvx",
"args": ["terminal-toolkit-mcp"]
}
async with MCPClient(config) as client:
# List available tools
tools = await client.list_mcp_tools()
print("Available tools:", [tool.name for tool in tools.tools])
# Execute a shell command
result = await client.call_tool(
"shell_exec",
{"id": "main", "command": "ls -la"}
)
print("Command output:", result.content[0].text)
asyncio.run(main())
```
#### Option 2: Using MCPToolkit (Recommended for Agents)
```python
import asyncio
from pathlib import Path
from camel.agents import ChatAgent
from camel.models import ModelFactory
from camel.toolkits import MCPToolkit
from camel.types import ModelPlatformType, ModelType
async def main():
# Configuration for terminal toolkit
config = {
"mcpServers": {
"terminal-toolkit": {
"command": "uvx",
"args": ["terminal-toolkit-mcp"]
}
}
}
# Connect to MCP server
async with MCPToolkit(config=config) as mcp_toolkit:
# Create an agent with terminal tools
model = ModelFactory.create(
model_platform=ModelPlatformType.DEFAULT,
model_type=ModelType.DEFAULT,
)
agent = ChatAgent(
system_message="You are a helpful assistant with terminal access.",
model=model,
tools=[*mcp_toolkit.get_tools()],
)
# Use the agent
response = await agent.astep(
"List the files in the current directory and show their sizes"
)
print(response.msgs[0].content)
asyncio.run(main())
```
### Configuration Options
You can customize the server behavior by passing additional arguments:
```json
{
"mcpServers": {
"terminal-toolkit": {
"command": "uvx",
"args": [
"terminal-toolkit-mcp",
"--working-directory", "/path/to/workspace",
"--timeout", "30.0",
"--safe-mode"
]
}
}
}
```
Available configuration options:
- `--working-directory PATH`: Set the working directory for terminal operations
- `--timeout SECONDS`: Set timeout for operations (default: 20.0)
- `--safe-mode` / `--no-safe-mode`: Enable/disable safe mode (default: enabled)
- `--interactive`: Enable interactive mode for commands requiring input
### Alternative Installation Methods
If you have the package installed locally, you can also use:
```json
{
"mcpServers": {
"terminal-toolkit": {
"command": "terminal-toolkit-mcp"
}
}
}
```
Or if you prefer the legacy executable name:
```json
{
"mcpServers": {
"terminal-toolkit": {
"command": "uvx",
"args": ["--from", "terminal-toolkit-mcp", "camel-terminal-mcp"]
}
}
}
```
## Complete Usage Examples
### Example 1: Basic Terminal Operations
```python
import asyncio
from camel.utils.mcp_client import MCPClient
async def terminal_example():
config = {
"command": "uvx",
"args": ["terminal-toolkit-mcp"]
}
async with MCPClient(config) as client:
# Start a shell session and run commands
session_id = "demo"
# List directory contents
result = await client.call_tool(
"shell_exec",
{"id": session_id, "command": "pwd && ls -la"}
)
print("Directory listing:")
print(result.content[0].text)
# Create a file and check it
await client.call_tool(
"shell_exec",
{"id": session_id, "command": "echo 'Hello MCP!' > test.txt"}
)
result = await client.call_tool(
"shell_exec",
{"id": session_id, "command": "cat test.txt"}
)
print("File contents:")
print(result.content[0].text)
# Clean up
await client.call_tool(
"shell_exec",
{"id": session_id, "command": "rm test.txt"}
)
asyncio.run(terminal_example())
```
### Example 2: Interactive Process Management
```python
import asyncio
from camel.utils.mcp_client import MCPClient
async def interactive_example():
config = {
"command": "uvx",
"args": ["terminal-toolkit-mcp", "--interactive"]
}
async with MCPClient(config) as client:
session_id = "interactive"
# Start an interactive process (e.g., Python REPL)
await client.call_tool(
"shell_exec",
{"id": session_id, "command": "python3"}
)
# Send input to the running process
await client.call_tool(
"shell_write_to_process",
{
"id": session_id,
"input": "print('Hello from Python!')",
"press_enter": True
}
)
# Wait and view output
await client.call_tool("shell_wait", {"id": session_id, "seconds": 1})
result = await client.call_tool("shell_view", {"id": session_id})
print("Python output:")
print(result.content[0].text)
# Exit Python
await client.call_tool(
"shell_write_to_process",
{"id": session_id, "input": "exit()", "press_enter": True}
)
asyncio.run(interactive_example())
```
### Example 3: Agent with Terminal Access
```python
import asyncio
from camel.agents import ChatAgent
from camel.models import ModelFactory
from camel.toolkits import MCPToolkit
from camel.types import ModelPlatformType, ModelType
async def agent_example():
config = {
"mcpServers": {
"terminal": {
"command": "uvx",
"args": ["terminal-toolkit-mcp"]
}
}
}
async with MCPToolkit(config=config) as mcp_toolkit:
model = ModelFactory.create(
model_platform=ModelPlatformType.DEFAULT,
model_type=ModelType.DEFAULT,
)
agent = ChatAgent(
system_message="You are a helpful coding assistant with terminal access. "
"Use the terminal tools to help users with their tasks.",
model=model,
tools=[*mcp_toolkit.get_tools()],
)
# Example tasks
tasks = [
"Create a simple Python script that prints 'Hello World' and run it",
"Check the current Git status and show me the recent commits",
"Find all Python files in the current directory and count the lines of code"
]
for task in tasks:
print(f"\nš¤ Task: {task}")
response = await agent.astep(task)
print(f"š Response: {response.msgs[0].content}")
asyncio.run(agent_example())
```
## Safety Features
When safe mode is enabled (default):
- Commands are restricted to the working directory
- Dangerous system commands are blocked
- File operations are limited to the workspace
- Network commands are prohibited
## Development
### Setup Development Environment
```bash
uv venv
source .venv/bin/activate
uv pip install -e ".[dev]"
```
### Running Tests
```bash
pytest
```
### Code Formatting
```bash
ruff check .
ruff format .
```
## Troubleshooting
### Common Issues
#### 1. "An executable named `terminal-toolkit-mcp` is not provided"
If you see this error, it means the package isn't properly installed or uvx is using a cached version. Try:
```bash
# Clear uvx cache and reinstall
uvx --from terminal-toolkit-mcp==0.1.2 terminal-toolkit-mcp --help
# Or use the legacy executable name
uvx --from terminal-toolkit-mcp camel-terminal-mcp --help
```
#### 2. MCP Connection Failed
Ensure the server starts correctly:
```bash
# Test the server directly
terminal-toolkit-mcp --help
# Check if uvx can run it
uvx terminal-toolkit-mcp --help
```
#### 3. Permission Denied Errors
In safe mode (default), some operations might be restricted. You can:
- Use `--working-directory` to set an appropriate workspace
- Disable safe mode with `--no-safe-mode` (not recommended for production)
#### 4. Tool Parameter Validation Errors
Make sure to provide all required parameters:
```python
# Correct usage
await client.call_tool("shell_exec", {"id": "session1", "command": "ls"})
# Missing required 'id' parameter will cause an error
await client.call_tool("shell_exec", {"command": "ls"}) # ā Error
```
### Debug Mode
Enable verbose logging by setting the environment variable:
```bash
export PYTHONPATH=.
python -m camel_terminal_toolkit.server --help
```
## License
Apache License 2.0 - see the CAMEL-AI project for full license details.
## Contributing
This project is part of the CAMEL-AI ecosystem. Please refer to the main CAMEL repository for contribution guidelines.
## Changelog
### v0.1.2
- **Complete MCP configuration documentation**: Added comprehensive guides for Claude Desktop, CAMEL Framework, and other MCP clients
- **Working examples**: Added complete usage examples for basic operations, interactive processes, and agent integration
- **Troubleshooting guide**: Added detailed troubleshooting section with common issues and solutions
- **Verified PyPI integration**: Confirmed simple configuration `uvx terminal-toolkit-mcp` works with PyPI package
- **Enhanced client examples**: Updated examples with actual working output demonstrations
### v0.1.1
- Fixed executable name configuration
- Added support for both `terminal-toolkit-mcp` and `camel-terminal-mcp` executables
- Updated documentation with comprehensive MCP configuration examples
- Improved client configuration examples
### v0.1.0
- Initial release
- Basic terminal toolkit functionality
- MCP server implementation
- Safe mode and interactive support
Raw data
{
"_id": null,
"home_page": null,
"name": "terminal-toolkit-mcp",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.10",
"maintainer_email": null,
"keywords": "mcp, terminal, shell, camel, ai, toolkit, server",
"author": null,
"author_email": "\"CAMEL-AI.org\" <noreply@camel-ai.org>",
"download_url": "https://files.pythonhosted.org/packages/b8/27/e49488cb72e1fc6bce9685ae25918473cb97131a55e2f870fb1fd720c756/terminal_toolkit_mcp-0.1.2.tar.gz",
"platform": null,
"description": "# CAMEL Terminal Toolkit MCP Server\n\nThis is a standalone MCP (Model Context Protocol) server that exports the CAMEL Terminal Toolkit functionality. It allows LLM clients to execute terminal commands safely through the MCP protocol.\n\n## Features\n\n- **Shell Execution**: Execute shell commands in managed sessions\n- **Session Management**: Create and manage multiple shell sessions\n- **Safe Mode**: Restrict dangerous operations and enforce working directory boundaries\n- **Interactive Support**: Support for interactive commands (Linux/macOS only)\n- **Process Management**: Control running processes (view, wait, write input, kill)\n- **Human Takeover**: Request human assistance when needed\n\n## Installation\n\n### Option 1: Using uvx (Recommended)\n\nThe easiest way to use this MCP server is with `uvx`, which will automatically install and run it:\n\n```bash\nuvx terminal-toolkit-mcp\n```\n\n### Option 2: Using pip\n\n```bash\npip install terminal-toolkit-mcp\n```\n\n### Option 3: Development Installation\n\n```bash\ngit clone https://github.com/camel-ai/terminal-toolkit-mcp.git\ncd terminal-toolkit-mcp\npip install -e .\n```\n\n## Usage\n\n### As an MCP Server\n\nStart the server with stdio transport:\n\n```bash\nterminal-toolkit-mcp\n```\n\n### Command Line Options\n\n- `--working-directory PATH`: Set the working directory for operations\n- `--timeout SECONDS`: Set timeout for operations (default: 20.0)\n- `--safe-mode` / `--no-safe-mode`: Enable/disable safe mode (default: enabled)\n- `--interactive`: Enable interactive mode for commands requiring input\n- `--transport {stdio}`: Set transport type (currently only stdio supported)\n\n### Example\n\n```bash\n# Start with custom working directory and increased timeout\nterminal-toolkit-mcp --working-directory /tmp/workspace --timeout 60.0\n\n# Start with safe mode disabled (not recommended)\nterminal-toolkit-mcp --no-safe-mode\n```\n\n## Available Tools\n\nThe server exposes the following tools through MCP:\n\n1. **shell_exec(id, command)**: Execute a shell command in a session\n2. **shell_view(id)**: View the output history of a session \n3. **shell_wait(id, seconds)**: Wait for a running command to complete\n4. **shell_write_to_process(id, input, press_enter)**: Send input to a running process\n5. **shell_kill_process(id)**: Terminate a running process\n6. **ask_user_for_help(id)**: Request human assistance\n\n## MCP Client Configuration\n\nTo use this server with MCP clients, you need to configure your client to connect to the terminal toolkit server. Here are examples for different scenarios:\n\n### For Claude Desktop\n\nAdd this configuration to your Claude Desktop settings (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):\n\n```json\n{\n \"mcpServers\": {\n \"terminal-toolkit\": {\n \"command\": \"uvx\",\n \"args\": [\"terminal-toolkit-mcp\"]\n }\n }\n}\n```\n\n### For CAMEL Framework\n\n#### Option 1: Using MCPClient (Direct Connection)\n\n```python\nimport asyncio\nfrom camel.utils.mcp_client import MCPClient\n\nasync def main():\n config = {\n \"command\": \"uvx\",\n \"args\": [\"terminal-toolkit-mcp\"]\n }\n \n async with MCPClient(config) as client:\n # List available tools\n tools = await client.list_mcp_tools()\n print(\"Available tools:\", [tool.name for tool in tools.tools])\n \n # Execute a shell command\n result = await client.call_tool(\n \"shell_exec\", \n {\"id\": \"main\", \"command\": \"ls -la\"}\n )\n print(\"Command output:\", result.content[0].text)\n\nasyncio.run(main())\n```\n\n#### Option 2: Using MCPToolkit (Recommended for Agents)\n\n```python\nimport asyncio\nfrom pathlib import Path\nfrom camel.agents import ChatAgent\nfrom camel.models import ModelFactory\nfrom camel.toolkits import MCPToolkit\nfrom camel.types import ModelPlatformType, ModelType\n\nasync def main():\n # Configuration for terminal toolkit\n config = {\n \"mcpServers\": {\n \"terminal-toolkit\": {\n \"command\": \"uvx\",\n \"args\": [\"terminal-toolkit-mcp\"]\n }\n }\n }\n \n # Connect to MCP server\n async with MCPToolkit(config=config) as mcp_toolkit:\n # Create an agent with terminal tools\n model = ModelFactory.create(\n model_platform=ModelPlatformType.DEFAULT,\n model_type=ModelType.DEFAULT,\n )\n \n agent = ChatAgent(\n system_message=\"You are a helpful assistant with terminal access.\",\n model=model,\n tools=[*mcp_toolkit.get_tools()],\n )\n \n # Use the agent\n response = await agent.astep(\n \"List the files in the current directory and show their sizes\"\n )\n print(response.msgs[0].content)\n\nasyncio.run(main())\n```\n\n### Configuration Options\n\nYou can customize the server behavior by passing additional arguments:\n\n```json\n{\n \"mcpServers\": {\n \"terminal-toolkit\": {\n \"command\": \"uvx\",\n \"args\": [\n \"terminal-toolkit-mcp\",\n \"--working-directory\", \"/path/to/workspace\",\n \"--timeout\", \"30.0\",\n \"--safe-mode\"\n ]\n }\n }\n}\n```\n\nAvailable configuration options:\n- `--working-directory PATH`: Set the working directory for terminal operations\n- `--timeout SECONDS`: Set timeout for operations (default: 20.0)\n- `--safe-mode` / `--no-safe-mode`: Enable/disable safe mode (default: enabled)\n- `--interactive`: Enable interactive mode for commands requiring input\n\n### Alternative Installation Methods\n\nIf you have the package installed locally, you can also use:\n\n```json\n{\n \"mcpServers\": {\n \"terminal-toolkit\": {\n \"command\": \"terminal-toolkit-mcp\"\n }\n }\n}\n```\n\nOr if you prefer the legacy executable name:\n\n```json\n{\n \"mcpServers\": {\n \"terminal-toolkit\": {\n \"command\": \"uvx\",\n \"args\": [\"--from\", \"terminal-toolkit-mcp\", \"camel-terminal-mcp\"]\n }\n }\n}\n```\n\n## Complete Usage Examples\n\n### Example 1: Basic Terminal Operations\n\n```python\nimport asyncio\nfrom camel.utils.mcp_client import MCPClient\n\nasync def terminal_example():\n config = {\n \"command\": \"uvx\",\n \"args\": [\"terminal-toolkit-mcp\"]\n }\n \n async with MCPClient(config) as client:\n # Start a shell session and run commands\n session_id = \"demo\"\n \n # List directory contents\n result = await client.call_tool(\n \"shell_exec\", \n {\"id\": session_id, \"command\": \"pwd && ls -la\"}\n )\n print(\"Directory listing:\")\n print(result.content[0].text)\n \n # Create a file and check it\n await client.call_tool(\n \"shell_exec\",\n {\"id\": session_id, \"command\": \"echo 'Hello MCP!' > test.txt\"}\n )\n \n result = await client.call_tool(\n \"shell_exec\",\n {\"id\": session_id, \"command\": \"cat test.txt\"}\n )\n print(\"File contents:\")\n print(result.content[0].text)\n \n # Clean up\n await client.call_tool(\n \"shell_exec\",\n {\"id\": session_id, \"command\": \"rm test.txt\"}\n )\n\nasyncio.run(terminal_example())\n```\n\n### Example 2: Interactive Process Management\n\n```python\nimport asyncio\nfrom camel.utils.mcp_client import MCPClient\n\nasync def interactive_example():\n config = {\n \"command\": \"uvx\",\n \"args\": [\"terminal-toolkit-mcp\", \"--interactive\"]\n }\n \n async with MCPClient(config) as client:\n session_id = \"interactive\"\n \n # Start an interactive process (e.g., Python REPL)\n await client.call_tool(\n \"shell_exec\",\n {\"id\": session_id, \"command\": \"python3\"}\n )\n \n # Send input to the running process\n await client.call_tool(\n \"shell_write_to_process\",\n {\n \"id\": session_id,\n \"input\": \"print('Hello from Python!')\",\n \"press_enter\": True\n }\n )\n \n # Wait and view output\n await client.call_tool(\"shell_wait\", {\"id\": session_id, \"seconds\": 1})\n \n result = await client.call_tool(\"shell_view\", {\"id\": session_id})\n print(\"Python output:\")\n print(result.content[0].text)\n \n # Exit Python\n await client.call_tool(\n \"shell_write_to_process\",\n {\"id\": session_id, \"input\": \"exit()\", \"press_enter\": True}\n )\n\nasyncio.run(interactive_example())\n```\n\n### Example 3: Agent with Terminal Access\n\n```python\nimport asyncio\nfrom camel.agents import ChatAgent\nfrom camel.models import ModelFactory\nfrom camel.toolkits import MCPToolkit\nfrom camel.types import ModelPlatformType, ModelType\n\nasync def agent_example():\n config = {\n \"mcpServers\": {\n \"terminal\": {\n \"command\": \"uvx\",\n \"args\": [\"terminal-toolkit-mcp\"]\n }\n }\n }\n \n async with MCPToolkit(config=config) as mcp_toolkit:\n model = ModelFactory.create(\n model_platform=ModelPlatformType.DEFAULT,\n model_type=ModelType.DEFAULT,\n )\n \n agent = ChatAgent(\n system_message=\"You are a helpful coding assistant with terminal access. \"\n \"Use the terminal tools to help users with their tasks.\",\n model=model,\n tools=[*mcp_toolkit.get_tools()],\n )\n \n # Example tasks\n tasks = [\n \"Create a simple Python script that prints 'Hello World' and run it\",\n \"Check the current Git status and show me the recent commits\",\n \"Find all Python files in the current directory and count the lines of code\"\n ]\n \n for task in tasks:\n print(f\"\\n\ud83e\udd16 Task: {task}\")\n response = await agent.astep(task)\n print(f\"\ud83d\udcdd Response: {response.msgs[0].content}\")\n\nasyncio.run(agent_example())\n```\n\n## Safety Features\n\nWhen safe mode is enabled (default):\n\n- Commands are restricted to the working directory\n- Dangerous system commands are blocked\n- File operations are limited to the workspace\n- Network commands are prohibited\n\n## Development\n\n### Setup Development Environment\n\n```bash\nuv venv\nsource .venv/bin/activate\nuv pip install -e \".[dev]\"\n```\n\n### Running Tests\n\n```bash\npytest\n```\n\n### Code Formatting\n\n```bash\nruff check .\nruff format .\n```\n\n## Troubleshooting\n\n### Common Issues\n\n#### 1. \"An executable named `terminal-toolkit-mcp` is not provided\"\n\nIf you see this error, it means the package isn't properly installed or uvx is using a cached version. Try:\n\n```bash\n# Clear uvx cache and reinstall\nuvx --from terminal-toolkit-mcp==0.1.2 terminal-toolkit-mcp --help\n\n# Or use the legacy executable name\nuvx --from terminal-toolkit-mcp camel-terminal-mcp --help\n```\n\n#### 2. MCP Connection Failed\n\nEnsure the server starts correctly:\n\n```bash\n# Test the server directly\nterminal-toolkit-mcp --help\n\n# Check if uvx can run it\nuvx terminal-toolkit-mcp --help\n```\n\n#### 3. Permission Denied Errors\n\nIn safe mode (default), some operations might be restricted. You can:\n\n- Use `--working-directory` to set an appropriate workspace\n- Disable safe mode with `--no-safe-mode` (not recommended for production)\n\n#### 4. Tool Parameter Validation Errors\n\nMake sure to provide all required parameters:\n\n```python\n# Correct usage\nawait client.call_tool(\"shell_exec\", {\"id\": \"session1\", \"command\": \"ls\"})\n\n# Missing required 'id' parameter will cause an error\nawait client.call_tool(\"shell_exec\", {\"command\": \"ls\"}) # \u274c Error\n```\n\n### Debug Mode\n\nEnable verbose logging by setting the environment variable:\n\n```bash\nexport PYTHONPATH=.\npython -m camel_terminal_toolkit.server --help\n```\n\n## License\n\nApache License 2.0 - see the CAMEL-AI project for full license details.\n\n## Contributing\n\nThis project is part of the CAMEL-AI ecosystem. Please refer to the main CAMEL repository for contribution guidelines.\n\n## Changelog\n\n### v0.1.2\n- **Complete MCP configuration documentation**: Added comprehensive guides for Claude Desktop, CAMEL Framework, and other MCP clients\n- **Working examples**: Added complete usage examples for basic operations, interactive processes, and agent integration\n- **Troubleshooting guide**: Added detailed troubleshooting section with common issues and solutions\n- **Verified PyPI integration**: Confirmed simple configuration `uvx terminal-toolkit-mcp` works with PyPI package\n- **Enhanced client examples**: Updated examples with actual working output demonstrations\n\n### v0.1.1\n- Fixed executable name configuration\n- Added support for both `terminal-toolkit-mcp` and `camel-terminal-mcp` executables\n- Updated documentation with comprehensive MCP configuration examples\n- Improved client configuration examples\n\n### v0.1.0\n- Initial release\n- Basic terminal toolkit functionality\n- MCP server implementation\n- Safe mode and interactive support\n",
"bugtrack_url": null,
"license": null,
"summary": "CAMEL Terminal Toolkit as a standalone MCP server",
"version": "0.1.2",
"project_urls": {
"Bug Tracker": "https://github.com/camel-ai/terminal-toolkit-mcp/issues",
"Documentation": "https://docs.camel-ai.org",
"Homepage": "https://github.com/camel-ai/terminal-toolkit-mcp",
"Repository": "https://github.com/camel-ai/terminal-toolkit-mcp"
},
"split_keywords": [
"mcp",
" terminal",
" shell",
" camel",
" ai",
" toolkit",
" server"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "c0819cae32d2b928bcb98be71cb072407f15e8af83b332c87807f6cb41f82268",
"md5": "c7ab04f152cb46e5844988eb98053dca",
"sha256": "13ee8724a817fcc6aedb77093971faf39417f85d8b819118e840c62181c52071"
},
"downloads": -1,
"filename": "terminal_toolkit_mcp-0.1.2-py3-none-any.whl",
"has_sig": false,
"md5_digest": "c7ab04f152cb46e5844988eb98053dca",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.10",
"size": 7935,
"upload_time": "2025-08-21T12:23:08",
"upload_time_iso_8601": "2025-08-21T12:23:08.075650Z",
"url": "https://files.pythonhosted.org/packages/c0/81/9cae32d2b928bcb98be71cb072407f15e8af83b332c87807f6cb41f82268/terminal_toolkit_mcp-0.1.2-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "b827e49488cb72e1fc6bce9685ae25918473cb97131a55e2f870fb1fd720c756",
"md5": "829449a0b46056b1f1657a2c2dbe48fc",
"sha256": "a337d92d9a02479cd4a2b3b8211dcde7db17bd4e001a9cd2bcc46c570d32e1b2"
},
"downloads": -1,
"filename": "terminal_toolkit_mcp-0.1.2.tar.gz",
"has_sig": false,
"md5_digest": "829449a0b46056b1f1657a2c2dbe48fc",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.10",
"size": 10804,
"upload_time": "2025-08-21T12:23:09",
"upload_time_iso_8601": "2025-08-21T12:23:09.238958Z",
"url": "https://files.pythonhosted.org/packages/b8/27/e49488cb72e1fc6bce9685ae25918473cb97131a55e2f870fb1fd720c756/terminal_toolkit_mcp-0.1.2.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-08-21 12:23:09",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "camel-ai",
"github_project": "terminal-toolkit-mcp",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"lcname": "terminal-toolkit-mcp"
}
JSON
