mirror of
https://github.com/hanzoai/stack.git
synced 2026-11-19 03:06:57 +00:00
123 lines
3.7 KiB
Python
123 lines
3.7 KiB
Python
"""Bash/Shell tool for command execution."""
|
|
|
|
import os
|
|
import platform
|
|
from typing import Optional, override
|
|
from pathlib import Path
|
|
|
|
from mcp.server import FastMCP
|
|
from mcp.server.fastmcp import Context as MCPContext
|
|
|
|
from hanzo_mcp.tools.shell.base_process import BaseScriptTool
|
|
|
|
|
|
class BashTool(BaseScriptTool):
|
|
"""Tool for running shell commands."""
|
|
|
|
name = "bash"
|
|
|
|
def register(self, server: FastMCP) -> None:
|
|
"""Register the tool with the MCP server."""
|
|
tool_self = self
|
|
|
|
@server.tool(name=self.name, description=self.description)
|
|
async def bash(
|
|
ctx: MCPContext,
|
|
command: str,
|
|
cwd: Optional[str] = None,
|
|
env: Optional[dict[str, str]] = None,
|
|
timeout: Optional[int] = None,
|
|
) -> str:
|
|
return await tool_self.run(
|
|
ctx, command=command, cwd=cwd, env=env, timeout=timeout
|
|
)
|
|
|
|
async def call(self, ctx: MCPContext, **params) -> str:
|
|
"""Call the tool with arguments."""
|
|
return await self.run(
|
|
ctx,
|
|
command=params["command"],
|
|
cwd=params.get("cwd"),
|
|
env=params.get("env"),
|
|
timeout=params.get("timeout"),
|
|
)
|
|
|
|
@property
|
|
@override
|
|
def description(self) -> str:
|
|
"""Get the tool description."""
|
|
return """Run shell commands with automatic backgrounding for long-running processes.
|
|
|
|
Commands that run for more than 2 minutes will automatically continue in the background.
|
|
You can check their status and logs using the 'process' tool.
|
|
|
|
Usage:
|
|
bash "ls -la"
|
|
bash "python server.py" # Auto-backgrounds after 2 minutes
|
|
bash "git status && git diff"
|
|
bash "npm run dev" --cwd ./frontend # Auto-backgrounds if needed"""
|
|
|
|
@override
|
|
def get_interpreter(self) -> str:
|
|
"""Get the bash interpreter."""
|
|
if platform.system() == "Windows":
|
|
# Try to find bash on Windows (Git Bash, WSL, etc.)
|
|
bash_paths = [
|
|
"C:\\Program Files\\Git\\bin\\bash.exe",
|
|
"C:\\cygwin64\\bin\\bash.exe",
|
|
"C:\\msys64\\usr\\bin\\bash.exe",
|
|
]
|
|
for path in bash_paths:
|
|
if Path(path).exists():
|
|
return path
|
|
return "cmd.exe" # Fall back to cmd if no bash found
|
|
|
|
# On Unix-like systems, always use bash
|
|
return "bash"
|
|
|
|
@override
|
|
def get_script_flags(self) -> list[str]:
|
|
"""Get interpreter flags."""
|
|
if platform.system() == "Windows":
|
|
return ["/c"]
|
|
return ["-c"]
|
|
|
|
@override
|
|
def get_tool_name(self) -> str:
|
|
"""Get the tool name."""
|
|
return "bash"
|
|
|
|
@override
|
|
async def run(
|
|
self,
|
|
ctx: MCPContext,
|
|
command: str,
|
|
cwd: Optional[str] = None,
|
|
env: Optional[dict[str, str]] = None,
|
|
timeout: Optional[int] = None,
|
|
) -> str:
|
|
"""Run a shell command with auto-backgrounding.
|
|
|
|
Args:
|
|
ctx: MCP context
|
|
command: Shell command to execute
|
|
cwd: Working directory
|
|
env: Environment variables
|
|
timeout: Command timeout in seconds (ignored - auto-backgrounds after 2 minutes)
|
|
|
|
Returns:
|
|
Command output or background status
|
|
"""
|
|
# Prepare working directory
|
|
work_dir = Path(cwd).resolve() if cwd else Path.cwd()
|
|
|
|
# Always use execute_sync which now has auto-backgrounding
|
|
output = await self.execute_sync(
|
|
command, cwd=work_dir, env=env, timeout=timeout
|
|
)
|
|
return output if output else "Command completed successfully (no output)"
|
|
|
|
|
|
# Create tool instance
|
|
bash_tool = BashTool()
|