forbin-mcp 0.1.0__py3-none-any.whl

forbin/display.py

@@ -0,0 +1,260 @@
+import json
+from typing import List, Any, Optional
+from rich.console import Console, Group
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
+from rich.syntax import Syntax
+from rich.control import Control
+from rich.segment import ControlType
+
+# Global console instance with constrained width for better readability
+console = Console(width=100)
+
+
+def display_logo():
+    """Display the Forbin ASCII logo."""
+    logo = """
+[bold cyan]
+  ███████╗ ██████╗ ██████╗ ██████╗ ██╗███╗   ██╗
+  ██╔════╝██╔═══██╗██╔══██╗██╔══██╗██║████╗  ██║
+  █████╗  ██║   ██║██████╔╝██████╔╝██║██╔██╗ ██║
+  ██╔══╝  ██║   ██║██╔══██╗██╔══██╗██║██║╚██╗██║
+  ██║     ╚██████╔╝██║  ██║██████╔╝██║██║ ╚████║
+  ╚═╝      ╚═════╝ ╚═╝  ╚═╝╚═════╝ ╚═╝╚═╝  ╚═══╝[/bold cyan]
+[dim]         MCP Remote Tool Tester v1.0.0[/dim]
+[italic dim]    "This is the voice of world control..."[/italic dim]
+"""
+    console.print(logo)
+
+
+def display_config_panel(server_url: Optional[str], health_url: Optional[str] = None):
+    """Display configuration information in a panel."""
+
+    config_table = Table.grid(padding=(0, 2))
+    config_table.add_column(style="bold cyan", justify="right")
+    config_table.add_column(style="white")
+
+    server_url_display = server_url or "[dim]Not configured[/dim]"
+    config_table.add_row("Server URL:", server_url_display)
+    if health_url:
+        config_table.add_row("Health URL:", health_url)
+    else:
+        config_table.add_row("Health URL:", "[dim]Not configured[/dim]")
+
+    console.print()
+    console.print(
+        Panel(
+            config_table,
+            title="[bold]Configuration[/bold]",
+            title_align="left",
+            border_style="cyan",
+            padding=(1, 2),
+        )
+    )
+    console.print()
+
+
+def display_step(
+    step_num: int, total_steps: int, title: str, status: str = "in_progress", update: bool = False
+):
+    """Display a step indicator with status.
+
+    Args:
+        step_num: Current step number
+        total_steps: Total number of steps
+        title: Step title
+        status: One of 'in_progress', 'success', 'skip'
+        update: If True, updates the previous line instead of creating a new one
+    """
+    icons = {"in_progress": ">", "success": "+", "skip": "-"}
+
+    colors = {"in_progress": "yellow", "success": "green", "skip": "dim"}
+
+    icon = icons.get(status, "*")
+    color = colors.get(status, "white")
+
+    step_text = f"[{color}]{icon} Step {step_num}/{total_steps}:[/{color}] [bold {color}]{title}[/bold {color}]"
+
+    if update:
+        # Move cursor up one line and clear it, then print the updated status
+        console.control(Control((ControlType.CURSOR_UP, 1), (ControlType.ERASE_IN_LINE, 2)))
+        console.print(step_text)
+    else:
+        console.print(step_text)
+
+
+def display_tools(tools: List[Any]):
+    """Display a compact list of available tools."""
+    if not tools:
+        console.print(
+            Panel(
+                "No tools available on this server.", title="Available Tools", border_style="yellow"
+            )
+        )
+        return
+
+    console.print()
+    console.print("[bold underline]Available Tools[/bold underline]")
+    console.print()
+
+    for i, tool in enumerate(tools, 1):
+        description = tool.description.strip() if tool.description else "No description"
+        # Truncate long descriptions for compact display
+        if len(description) > 60:
+            description = description[:57] + "..."
+        console.print(
+            f"  [bold cyan]{i:2}[/bold cyan]. [white]{tool.name}[/white] [dim]- {description}[/dim]"
+        )
+
+    console.print()
+
+
+def _highlight_json_in_text(text: str):
+    """Highlight JSON content in text with syntax colors.
+
+    Detects JSON objects/arrays and applies basic syntax highlighting.
+    Returns a Text object with styled content.
+    """
+    import re
+
+    # Simple check if text looks like it contains JSON
+    if not any(char in text for char in ["{", "[", '":']):
+        return text
+
+    # Try to detect and highlight JSON-like patterns
+    result = Text()
+
+    # Pattern to match JSON-like content (simple approach)
+    # This will highlight common JSON patterns with colors
+    current_pos = 0
+
+    # Find JSON strings (simple pattern for "key": "value")
+    string_pattern = r'"([^"\\]*(\\.[^"\\]*)*)"'
+
+    for match in re.finditer(string_pattern, text):
+        # Add text before match
+        if match.start() > current_pos:
+            result.append(text[current_pos : match.start()])
+
+        # Add the matched string with color
+        matched_text = match.group(0)
+
+        # Check if this looks like a key (followed by :)
+        next_char_pos = match.end()
+        if next_char_pos < len(text) and text[next_char_pos : next_char_pos + 1].strip().startswith(
+            ":"
+        ):
+            result.append(matched_text, style="bold cyan")  # JSON key
+        else:
+            result.append(matched_text, style="green")  # JSON value
+
+        current_pos = match.end()
+
+    # Add remaining text
+    if current_pos < len(text):
+        remaining = text[current_pos:]
+        # Highlight other JSON syntax
+        remaining = remaining.replace("{", "{\u200b")  # Add zero-width space for splitting
+        remaining = remaining.replace("}", "}\u200b")
+        remaining = remaining.replace("[", "[\u200b")
+        remaining = remaining.replace("]", "]\u200b")
+        remaining = remaining.replace(":", ":\u200b")
+
+        for part in remaining.split("\u200b"):
+            if part in ["{", "}", "[", "]"]:
+                result.append(part, style="bold yellow")
+            elif part == ":":
+                result.append(part, style="dim")
+            else:
+                result.append(part)
+
+    return result if len(result) > 0 else text
+
+
+def display_tool_header(tool: Any):
+    """Display a simple header for the tool view."""
+    console.print()
+    console.rule(f"[bold cyan]{tool.name}[/bold cyan]")
+    console.print()
+
+
+def display_tool_menu():
+    """Display the tool view menu options."""
+    console.print("[bold underline]Options:[/bold underline]")
+    console.print("  [bold cyan]d[/bold cyan] - View details")
+    console.print("  [bold cyan]r[/bold cyan] - Run tool")
+    console.print("  [bold cyan]b[/bold cyan] - Back to tool list")
+    console.print("  [bold cyan]q[/bold cyan] - Quit")
+    console.print()
+
+
+def _parse_description_with_code_blocks(description: str) -> List[Any]:
+    """Parse description and extract code blocks for syntax highlighting."""
+    import re
+
+    content: List[Any] = []
+
+    # Pattern to match ```json ... ``` or ``` ... ``` code blocks
+    code_block_pattern = r"```(\w*)\n(.*?)```"
+
+    last_end = 0
+    for match in re.finditer(code_block_pattern, description, re.DOTALL):
+        # Add text before the code block
+        before_text = description[last_end : match.start()].strip()
+        if before_text:
+            content.append(Text(before_text))
+            content.append(Text(""))
+
+        # Get language and code
+        lang = match.group(1) or "json"
+        code = match.group(2).strip()
+
+        # Add syntax-highlighted code block
+        content.append(Syntax(code, lang, theme="monokai", line_numbers=False))
+        content.append(Text(""))
+
+        last_end = match.end()
+
+    # Add any remaining text after the last code block
+    remaining = description[last_end:].strip()
+    if remaining:
+        content.append(Text(remaining))
+
+    return content
+
+
+def display_tool_schema(tool: Any):
+    """Display detailed schema for a specific tool with syntax-highlighted JSON."""
+
+    content: List[Any] = []
+
+    # Description with parsed code blocks
+    if tool.description:
+        parsed_content = _parse_description_with_code_blocks(tool.description)
+        content.extend(parsed_content)
+        if parsed_content:
+            content.append(Text(""))
+
+    # Input Schema as syntax-highlighted JSON
+    if tool.inputSchema:
+        content.append(Text("Input Schema:", style="bold underline"))
+        content.append(Text(""))
+        json_str = json.dumps(tool.inputSchema, indent=2)
+        content.append(Syntax(json_str, "json", theme="monokai", line_numbers=False))
+    else:
+        content.append(Text("No input parameters required.", style="dim"))
+
+    # Combine all content
+    panel_content = Group(*content)
+
+    console.print()
+    console.print(
+        Panel(
+            panel_content,
+            title=f"[bold]{tool.name}[/bold] - Details",
+            border_style="blue",
+            expand=False,
+        )
+    )
+    console.print()

forbin/tools.py

@@ -0,0 +1,193 @@
+import asyncio
+import json
+from typing import Any, Dict, List, TYPE_CHECKING
+from rich.prompt import Prompt
+from rich.panel import Panel
+from rich.syntax import Syntax
+
+from .display import console
+
+if TYPE_CHECKING:
+    from .client import MCPSession
+
+
+async def list_tools(mcp_session: "MCPSession") -> List[Any]:
+    """
+    List all available tools from the MCP server.
+
+    Args:
+        mcp_session: Connected MCPSession
+
+    Returns:
+        List of tool objects
+    """
+    with console.status("  [dim]Retrieving tool manifest...[/dim]", spinner="dots"):
+        tools = await asyncio.wait_for(mcp_session.list_tools(), timeout=15.0)
+
+    return tools
+
+
+def parse_parameter_value(value_str: str, param_type: str) -> Any:
+    """Parse a string input into the appropriate type."""
+    if not value_str.strip():
+        return None
+
+    if param_type == "boolean":
+        return value_str.lower() in ("true", "t", "yes", "y", "1")
+    elif param_type == "integer":
+        try:
+            return int(value_str)
+        except ValueError:
+            # Re-raise to be caught by caller
+            raise
+    elif param_type == "number":
+        try:
+            return float(value_str)
+        except ValueError:
+            raise
+    elif param_type in ("object", "array"):
+        try:
+            return json.loads(value_str)
+        except json.JSONDecodeError:
+            raise
+    else:  # string
+        return value_str
+
+
+def get_tool_parameters(tool: Any) -> Dict[str, Any]:
+    """Interactively collect parameters for a tool."""
+    params: dict[str, Any] = {}
+
+    if not tool.inputSchema or not isinstance(tool.inputSchema, dict):
+        return params
+
+    properties = tool.inputSchema.get("properties", {})
+    required = tool.inputSchema.get("required", [])
+
+    if not properties:
+        return params
+
+    console.print()
+    console.rule("[bold cyan]ENTER PARAMETERS[/bold cyan]")
+    console.print("Enter parameter values (press [bold]Enter[/bold] to skip optional parameters)\n")
+
+    for param_name, param_info in properties.items():
+        param_type = param_info.get("type", "string")
+        param_desc = param_info.get("description", "")
+        is_required = param_name in required
+
+        # Show parameter info
+        req_str = "[red](required)[/red]" if is_required else "[green](optional)[/green]"
+        console.print(f"[bold cyan]{param_name}[/bold cyan] ({param_type}) {req_str}")
+        if param_desc:
+            console.print(f"  [dim]{param_desc}[/dim]")
+
+        # Show enum values if present
+        if "enum" in param_info:
+            console.print(f"  Allowed values: {', '.join(str(v) for v in param_info['enum'])}")
+
+        # Get value
+        while True:
+            try:
+                # We use generic Prompt and handle manual validation to support complex types and skipping
+                value_str = Prompt.ask("  ->", default="", show_default=False)
+
+                if not value_str:
+                    if is_required:
+                        console.print(
+                            "  [red]This parameter is required. Please enter a value.[/red]"
+                        )
+                        continue
+                    else:
+                        break
+
+                # Parse the value
+                value = parse_parameter_value(value_str, param_type)
+                params[param_name] = value
+                break
+
+            except (ValueError, json.JSONDecodeError) as e:
+                console.print(f"  [red]Invalid value for type {param_type}:[/red] {e}")
+                console.print("  Please try again.")
+
+        console.print()
+
+    return params
+
+
+async def call_tool(mcp_session: "MCPSession", tool: Any, params: Dict[str, Any]):
+    """Call a tool with the given parameters."""
+    console.print()
+    console.rule("[bold magenta]CALLING TOOL[/bold magenta]")
+    console.print(f"Tool: [bold]{tool.name}[/bold]")
+    console.print()
+
+    # Show parameters nicely
+    if params:
+        json_str = json.dumps(params, indent=2)
+        console.print(
+            Panel(
+                Syntax(json_str, "json", theme="monokai", line_numbers=False),
+                title="[bold]Parameters[/bold]",
+                title_align="left",
+                border_style="cyan",
+            )
+        )
+    else:
+        console.print("[dim]No parameters[/dim]")
+
+    console.print("\n[bold]Executing...[/bold]")
+
+    try:
+        with console.status("Waiting for response...", spinner="dots"):
+            result = await mcp_session.call_tool(tool.name, params)
+
+        console.print("\n[bold green]Tool execution completed![/bold green]\n")
+        console.rule("[bold green]RESULT[/bold green]")
+        console.print()
+
+        # Extract and display result
+        if result.content:
+            for item in result.content:
+                text = getattr(item, "text", None)
+                if text:
+                    # Try to detect if it looks like JSON for syntax highlighting
+                    text_stripped = text.strip()
+                    if text_stripped.startswith(("{", "[")) and text_stripped.endswith(("}", "]")):
+                        try:
+                            # Validate and pretty-print JSON
+                            parsed = json.loads(text_stripped)
+                            formatted = json.dumps(parsed, indent=2)
+                            console.print(
+                                Panel(
+                                    Syntax(formatted, "json", theme="monokai", line_numbers=False),
+                                    border_style="green",
+                                    title="[bold]Response[/bold]",
+                                    title_align="left",
+                                )
+                            )
+                            continue
+                        except json.JSONDecodeError:
+                            pass
+
+                    # For non-JSON text responses
+                    console.print(
+                        Panel(
+                            text.strip(),
+                            border_style="green",
+                            title="[bold]Response[/bold]",
+                            title_align="left",
+                        )
+                    )
+                else:
+                    console.print(str(item))
+        else:
+            console.print("[dim]No content returned[/dim]")
+
+        console.print()
+        console.rule()
+        console.print()
+
+    except Exception as e:
+        console.print(f"[bold red]Tool execution failed:[/bold red] {type(e).__name__}")
+        console.print(f"   Error: {e}\n")

forbin/utils.py

@@ -0,0 +1,111 @@
+import sys
+import asyncio
+import select
+from . import config
+
+
+# Suppress stderr warnings from MCP library (like "Session termination failed: 400")
+class FilteredStderr:
+    def __init__(self, original_stderr):
+        self.original_stderr = original_stderr
+        self.suppress_patterns = [
+            "Error in post_writer",
+            "Session termination failed",
+            "httpx.HTTPStatusError",
+            "streamable_http.py",
+            "Traceback (most recent call last)",
+            "File ",  # Suppress file paths in tracebacks
+            "raise ",
+            "await ",
+            "BrokenResourceError",
+            "ClosedResourceError",
+            "raise_for_status",
+            "handle_request_async",
+            "_handle_post_request",
+        ]
+        self.buffer = ""
+        self.suppressing = False
+        self.suppress_depth = 0
+
+    def write(self, text):
+        # If verbose mode is ON, don't suppress anything
+        if config.VERBOSE:
+            self.original_stderr.write(text)
+            return
+
+        # Check if this line starts a suppressible error block
+        if any(pattern in text for pattern in self.suppress_patterns):
+            self.suppressing = True
+            self.suppress_depth = 10  # Suppress next 10 lines
+            return
+
+        # If we're suppressing, decrement counter
+        if self.suppressing:
+            if text.strip() == "":
+                # Blank line ends suppression
+                self.suppressing = False
+                self.suppress_depth = 0
+            else:
+                # Any line during suppression decrements counter
+                self.suppress_depth -= 1
+                if self.suppress_depth <= 0:
+                    self.suppressing = False
+                    return
+
+            return
+
+        # If not suppressing, write to original stderr
+        if not self.suppressing:
+            self.original_stderr.write(text)
+
+    def flush(self):
+        self.original_stderr.flush()
+
+
+def setup_logging():
+    """Replace stderr with filtered version."""
+    sys.stderr = FilteredStderr(sys.stderr)
+
+
+async def listen_for_toggle():
+    """
+    Background task to listen for 'v' key to toggle verbose logging.
+    Uses non-blocking stdin read.
+    """
+    # Only try to import termios/tty on Unix-like systems
+    try:
+        import termios
+        import tty
+    except ImportError:
+        return
+
+    fd = sys.stdin.fileno()
+    # Check if we are in a terminal
+    if not sys.stdin.isatty():
+        return
+
+    old_settings = termios.tcgetattr(fd)
+    try:
+        tty.setcbreak(fd)
+        while True:
+            # Non-blocking check for input
+            if select.select([sys.stdin], [], [], 0.1)[0]:
+                char = sys.stdin.read(1).lower()
+                if char == "v":
+                    config.VERBOSE = not config.VERBOSE
+                    from .display import console
+
+                    status = (
+                        "[bold green]ON[/bold green]"
+                        if config.VERBOSE
+                        else "[bold red]OFF[/bold red]"
+                    )
+                    # Clear current line and print toggle status
+                    console.print(f"\n[bold cyan]Verbose logging toggled {status}[/bold cyan]")
+
+            await asyncio.sleep(0.1)
+    except Exception:
+        # Silently fail if something goes wrong with the terminal settings
+        pass
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)