r2mcp 0.1.0__tar.gz

r2mcp-0.1.0/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: r2mcp
+Version: 0.1.0
+Summary: CLI para gestao de servidores MCP via rest2mcp gateway
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.12.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: httpx
+
+# r2mcp
+
+CLI para gestão de servidores MCP via rest2mcp gateway.
+
+## Instalação
+
+Requer Python 3.10+ e pipx.
+
+```bash
+pipx install r2mcp
+```
+
+## Uso
+
+```bash
+r2mcp login
+r2mcp config set-env prod
+r2mcp servers create --name my-api --spec-url https://example.com/openapi.json
+r2mcp tools list <server_id>
+r2mcp tools call <server_id> <tool_name> --args '{"key": "value"}'
+r2mcp link cursor <server_id>
+r2mcp --help
+```
+
+## Desenvolvimento
+
+```bash
+pip install -e .
+python -m build
+```

r2mcp-0.1.0/README.md

@@ -0,0 +1,30 @@
+# r2mcp
+
+CLI para gestão de servidores MCP via rest2mcp gateway.
+
+## Instalação
+
+Requer Python 3.10+ e pipx.
+
+```bash
+pipx install r2mcp
+```
+
+## Uso
+
+```bash
+r2mcp login
+r2mcp config set-env prod
+r2mcp servers create --name my-api --spec-url https://example.com/openapi.json
+r2mcp tools list <server_id>
+r2mcp tools call <server_id> <tool_name> --args '{"key": "value"}'
+r2mcp link cursor <server_id>
+r2mcp --help
+```
+
+## Desenvolvimento
+
+```bash
+pip install -e .
+python -m build
+```

r2mcp-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "r2mcp"
+version = "0.1.0"
+description = "CLI para gestao de servidores MCP via rest2mcp gateway"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+dependencies = [
+    "typer>=0.12.0",
+    "rich>=13.0.0",
+    "httpx",
+]
+
+[project.scripts]
+r2mcp = "r2mcp_cli.main:app"
+
+[tool.setuptools.packages.find]
+include = ["r2mcp_cli", "r2mcp_cli.*"]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 120
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I"]

r2mcp-0.1.0/r2mcp.egg-info/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: r2mcp
+Version: 0.1.0
+Summary: CLI para gestao de servidores MCP via rest2mcp gateway
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.12.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: httpx
+
+# r2mcp
+
+CLI para gestão de servidores MCP via rest2mcp gateway.
+
+## Instalação
+
+Requer Python 3.10+ e pipx.
+
+```bash
+pipx install r2mcp
+```
+
+## Uso
+
+```bash
+r2mcp login
+r2mcp config set-env prod
+r2mcp servers create --name my-api --spec-url https://example.com/openapi.json
+r2mcp tools list <server_id>
+r2mcp tools call <server_id> <tool_name> --args '{"key": "value"}'
+r2mcp link cursor <server_id>
+r2mcp --help
+```
+
+## Desenvolvimento
+
+```bash
+pip install -e .
+python -m build
+```

r2mcp-0.1.0/r2mcp.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+README.md
+pyproject.toml
+r2mcp.egg-info/PKG-INFO
+r2mcp.egg-info/SOURCES.txt
+r2mcp.egg-info/dependency_links.txt
+r2mcp.egg-info/entry_points.txt
+r2mcp.egg-info/requires.txt
+r2mcp.egg-info/top_level.txt
+r2mcp_cli/__init__.py
+r2mcp_cli/api_client.py
+r2mcp_cli/config.py
+r2mcp_cli/main.py
+r2mcp_cli/commands/__init__.py
+r2mcp_cli/commands/auth.py
+r2mcp_cli/commands/link.py
+r2mcp_cli/commands/logs.py
+r2mcp_cli/commands/servers.py
+r2mcp_cli/commands/tools.py

r2mcp-0.1.0/r2mcp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

r2mcp-0.1.0/r2mcp.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+r2mcp = r2mcp_cli.main:app

r2mcp-0.1.0/r2mcp.egg-info/requires.txt

@@ -0,0 +1,3 @@
+typer>=0.12.0
+rich>=13.0.0
+httpx

r2mcp-0.1.0/r2mcp.egg-info/top_level.txt

@@ -0,0 +1 @@
+r2mcp_cli

r2mcp-0.1.0/r2mcp_cli/api_client.py

@@ -0,0 +1,108 @@
+import httpx
+from rich.console import Console
+
+from r2mcp_cli.config import get_base_url, get_token
+
+console = Console()
+
+
+class APIError(Exception):
+    def __init__(self, status_code: int, detail: str):
+        self.status_code = status_code
+        self.detail = detail
+        super().__init__(f"HTTP {status_code}: {detail}")
+
+
+class APIClient:
+    def __init__(self):
+        self.base_url = get_base_url()
+        self._client = httpx.Client(timeout=30.0)
+
+    def _headers(self) -> dict:
+        headers = {"Content-Type": "application/json"}
+        token = get_token()
+        if token:
+            headers["Authorization"] = f"Bearer {token}"
+        return headers
+
+    def _request(self, method: str, path: str, **kwargs) -> httpx.Response:
+        url = f"{self.base_url}{path}"
+        try:
+            resp = self._client.request(method, url, headers=self._headers(), **kwargs)
+        except (httpx.ConnectError, httpx.ReadError, httpx.TimeoutException) as e:
+            raise APIError(0, f"Erro de conexao: {e}")
+        if resp.status_code >= 400:
+            detail = self._extract_detail(resp)
+            raise APIError(resp.status_code, detail)
+        return resp
+
+    def _extract_detail(self, resp: httpx.Response) -> str:
+        try:
+            body = resp.json()
+            if isinstance(body, dict):
+                return body.get("detail", resp.text)
+            return resp.text
+        except Exception:
+            return resp.text
+
+    def get_me(self) -> dict:
+        resp = self._request("GET", "/v1/me")
+        return resp.json()
+
+    def list_servers(self) -> list[dict]:
+        resp = self._request("GET", "/v1/servers")
+        return resp.json()
+
+    def create_server(self, name: str, spec_url: str, transport: str = "sse") -> dict:
+        resp = self._request("POST", "/v1/servers", json={"name": name, "spec_url": spec_url, "transport": transport})
+        return resp.json()
+
+    def update_server(self, server_id: str, data: dict) -> dict:
+        resp = self._request("PATCH", f"/v1/servers/{server_id}", json=data)
+        return resp.json()
+
+    def delete_server(self, server_id: str):
+        self._request("DELETE", f"/v1/servers/{server_id}")
+
+    def list_tools(self, server_id: str) -> list[dict]:
+        resp = self._request("GET", f"/v1/servers/{server_id}/tools")
+        data = resp.json()
+        return data.get("tools", [])
+
+    def call_tool(self, server_id: str, tool_name: str, arguments: dict) -> dict:
+        resp = self._request(
+            "POST",
+            f"/v1/servers/{server_id}/tools/call",
+            json={"name": tool_name, "arguments": arguments},
+        )
+        return resp.json()
+
+    def get_logs(self, server_id: str, limit: int = 20) -> list[dict]:
+        resp = self._request("GET", f"/v1/servers/{server_id}/logs", params={"limit": limit})
+        return resp.json()
+
+    def get_auth_status(self, server_id: str) -> dict:
+        resp = self._request("GET", f"/v1/servers/{server_id}/auth")
+        return resp.json()
+
+    def get_server_health(self, server_id: str) -> dict:
+        resp = self._request("GET", f"/v1/servers/{server_id}/health")
+        return resp.json()
+
+    def login_server(self, server_id: str, credentials: dict) -> dict:
+        resp = self._request("POST", f"/v1/servers/{server_id}/auth/login", json=credentials)
+        return resp.json()
+
+    def set_credentials(self, server_id: str, credentials: dict) -> dict:
+        resp = self._request("PUT", f"/v1/servers/{server_id}/auth/credentials", json=credentials)
+        return resp.json()
+
+    def check_credentials(self, server_id: str) -> dict:
+        resp = self._request("GET", f"/v1/servers/{server_id}/auth/credentials")
+        return resp.json()
+
+    def delete_credentials(self, server_id: str):
+        self._request("DELETE", f"/v1/servers/{server_id}/auth/credentials")
+
+    def close(self):
+        self._client.close()

r2mcp-0.1.0/r2mcp_cli/commands/auth.py

@@ -0,0 +1,149 @@
+import typer
+from rich import box
+from rich.console import Console
+from rich.table import Table
+
+from r2mcp_cli.api_client import APIClient, APIError
+from r2mcp_cli.config import get_base_url, get_token, set_base_url, set_token, clear_token, validate_token
+
+console = Console()
+config_app = typer.Typer(help="Gerir configuracao local")
+
+
+def login():
+    token = get_token()
+    if token:
+        ok, _ = validate_token(token)
+        if not ok:
+            console.print(
+                "[yellow]Token expirado. Faz logout primeiro, obtém um novo em https://rest2mcp.pages.dev/ e faz login novamente.[/yellow]"
+            )
+            return
+        console.print("[yellow]Ja estas autenticado. Faz logout primeiro se quiseres mudar de conta.[/yellow]")
+        return
+
+    token = typer.prompt("Introduz o teu JWT do Supabase (obtem em https://rest2mcp.pages.dev/)", hide_input=True)
+    if not token:
+        console.print("[red]Token invalido.[/red]")
+        raise typer.Exit(1)
+
+    ok, msg = validate_token(token)
+    if not ok:
+        console.print(f"[red]Token invalido: {msg}[/red]")
+        raise typer.Exit(1)
+
+    set_token(token)
+
+    with console.status("[bold green]A testar conexao..."):
+        try:
+            client = APIClient()
+            me = client.get_me()
+            client.close()
+        except APIError as e:
+            clear_token()
+            console.print(f"[red]Erro na autenticacao: {e.detail}. Obtém um token em https://rest2mcp.pages.dev/[/red]")
+            raise typer.Exit(1)
+        except Exception as e:
+            clear_token()
+            console.print(f"[red]Erro de conexao: {e}. Obtém um token em https://rest2mcp.pages.dev/[/red]")
+            raise typer.Exit(1)
+
+    table = Table(box=box.SIMPLE)
+    table.add_column("Campo", style="bold cyan")
+    table.add_column("Valor")
+    table.add_row("Email", me.get("email", "-"))
+    table.add_row("Plano", me.get("plan_tier", "free"))
+    table.add_row("Servidores", f"{me.get('servers_count', 0)} / {me.get('servers_limit', 1)}")
+    console.print(table)
+    console.print("[green]Autenticado com sucesso![/green]")
+
+
+def logout():
+    if not get_token():
+        console.print("[yellow]Nao estás autenticado.[/yellow]")
+        return
+    clear_token()
+    console.print("[green]Token removido.[/green]")
+
+
+def me():
+    token = get_token()
+    if not token:
+        console.print(
+            "[red]ERRO: Nao autenticado. Obtém um token em https://rest2mcp.pages.dev/ e corre r2mcp login.[/red]"
+        )
+        raise typer.Exit(1)
+    ok, msg = validate_token(token)
+    if not ok:
+        console.print(f"[red]ERRO: {msg}. Obtém um token novo em https://rest2mcp.pages.dev/[/red]")
+        raise typer.Exit(1)
+
+    with console.status("[bold green]A obter informacoes do utilizador..."):
+        try:
+            client = APIClient()
+            data = client.get_me()
+            client.close()
+        except APIError as e:
+            if e.status_code in (401, 403):
+                console.print("[red]ERRO: Nao autenticado. Por favor, corre r2mcp login primeiro.[/red]")
+            else:
+                console.print(f"[red]Erro: {e.detail}[/red]")
+            raise typer.Exit(1)
+        except Exception as e:
+            console.print(f"[red]Erro de conexao: {e}[/red]")
+            raise typer.Exit(1)
+
+    table = Table(box=box.SIMPLE)
+    table.add_column("Campo", style="bold cyan")
+    table.add_column("Valor")
+    table.add_row("ID", data.get("id", "-"))
+    table.add_row("Email", data.get("email", "-"))
+    table.add_row("Nome", data.get("name", "-"))
+    table.add_row("Status", data.get("status", "-"))
+    table.add_row("Plano", data.get("plan_tier", "free"))
+    table.add_row("Servidores", f"{data.get('servers_count', 0)} / {data.get('servers_limit', 1)}")
+    console.print(table)
+
+
+PROD_URL = "https://rest2mcp.fly.dev"
+LOCAL_URL = "http://localhost:8080"
+
+
+@config_app.command(name="show")
+def config_show():
+    cfg_base = get_base_url()
+    token = get_token()
+    token_status = "[green]configurado[/green]" if token else "[dim]nenhum[/dim]"
+    if cfg_base == PROD_URL:
+        env = "[blue]producao[/blue]"
+    elif cfg_base == LOCAL_URL:
+        env = "[yellow]local[/yellow]"
+    else:
+        env = f"[magenta]custom[/magenta] ({cfg_base})"
+    table = Table(box=box.SIMPLE)
+    table.add_column("Configuracao", style="bold cyan")
+    table.add_column("Valor")
+    table.add_row("Ambiente", env)
+    table.add_row("API URL", cfg_base)
+    table.add_row("Token", token_status)
+    console.print(table)
+
+
+@config_app.command(name="set-env")
+def config_set_env(
+    env: str = typer.Argument(..., help="Ambiente: local ou prod"),
+):
+    if env == "local":
+        set_base_url(LOCAL_URL)
+    elif env == "prod":
+        set_base_url(PROD_URL)
+    else:
+        console.print(f"[red]Ambiente '{env}' invalido. Usa 'local' ou 'prod'.[/red]")
+        raise typer.Exit(1)
+    console.print(f"[green]Ambiente alterado para {env}: {get_base_url()}[/green]")
+
+
+@config_app.command(name="set-base")
+def set_base(base_url: str = typer.Argument(..., help="URL base da API")):
+    set_base_url(base_url)
+    console.print(f"[green]URL base alterada para: {get_base_url()}[/green]")

r2mcp-0.1.0/r2mcp_cli/commands/link.py

@@ -0,0 +1,186 @@
+import json
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from r2mcp_cli.api_client import APIClient, APIError
+from r2mcp_cli.config import get_token, validate_token
+
+console = Console()
+link_app = typer.Typer(help="Ligar servidor a editor IA")
+
+
+EDITOR_CONFIGS = {
+    "claude-code": {
+        "paths": lambda: [
+            Path.cwd() / ".mcp.json",
+            Path.home() / ".claude.json",
+        ],
+        "key": "mcpServers",
+    },
+    "cursor": {
+        "paths": lambda: [Path.cwd() / ".cursor" / "mcp.json", Path.home() / ".cursor" / "mcp.json"],
+        "key": "mcpServers",
+    },
+    "vscode": {
+        "paths": lambda: [Path.cwd() / ".vscode" / "mcp.json"],
+        "key": "servers",
+    },
+    "opencode": {
+        "paths": lambda: [Path.cwd() / "opencode.json"],
+        "key": "mcp",
+    },
+}
+
+
+def _require_auth():
+    token = get_token()
+    if not token:
+        console.print(
+            "[red]ERRO: Nao autenticado. Obtém um token em https://rest2mcp.pages.dev/ e corre r2mcp login.[/red]"
+        )
+        raise typer.Exit(1)
+    ok, msg = validate_token(token)
+    if not ok:
+        console.print(f"[red]ERRO: {msg}. Obtém um token novo em https://rest2mcp.pages.dev/[/red]")
+        raise typer.Exit(1)
+
+
+def _find_server(server_id: str) -> Optional[dict]:
+    client = APIClient()
+    try:
+        servers = client.list_servers()
+        client.close()
+    except APIError as e:
+        client.close()
+        console.print(f"[red]Erro: {e.detail}[/red]")
+        raise typer.Exit(1)
+    except Exception as e:
+        client.close()
+        console.print(f"[red]Erro de conexao: {e}[/red]")
+        raise typer.Exit(1)
+
+    for s in servers:
+        if s["server_id"] == server_id:
+            return s
+    return None
+
+
+def _resolve_config_path(editor: str) -> Optional[Path]:
+    info = EDITOR_CONFIGS.get(editor)
+    if not info:
+        return None
+    for p in info["paths"]():
+        if str(p).strip():
+            return p
+    return None
+
+
+def _read_json(path: Path) -> dict:
+    if path.exists():
+        try:
+            return json.loads(path.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError):
+            return {}
+    return {}
+
+
+@link_app.callback(invoke_without_command=True)
+def link(
+    editor: str = typer.Argument(..., help="Editor: claude-code, cursor, vscode, opencode"),
+    server_id: str = typer.Argument(..., help="ID do servidor"),
+):
+    _require_auth()
+
+    if editor not in EDITOR_CONFIGS:
+        console.print(f"[red]Editor '{editor}' nao suportado. Opcoes: {', '.join(EDITOR_CONFIGS.keys())}[/red]")
+        raise typer.Exit(1)
+
+    config_path = _resolve_config_path(editor)
+    if not config_path:
+        console.print(f"[red]Nao foi possivel determinar o caminho de configuracao para '{editor}'.[/red]")
+        raise typer.Exit(1)
+
+    server = _find_server(server_id)
+    if not server:
+        console.print(f"[red]Servidor '{server_id}' nao encontrado.[/red]")
+        raise typer.Exit(1)
+    if server["status"] == "active":
+        try:
+            client = APIClient()
+            auth_info = client.get_auth_status(server_id)
+            client.close()
+            if auth_info.get("required_fields") and not auth_info.get("authenticated"):
+                console.print(
+                    "[red]ERRO: Servidor precisa de autenticacao. Faz o login primeiro com 'r2mcp servers credentials'.[/red]"
+                )
+                raise typer.Exit(1)
+        except APIError:
+            pass
+    apikey = server.get("apikey", "")
+    url = f"http://localhost:8080/v1/{server_id}/{apikey}/mcp"
+    name = server.get("name", server_id)
+    transport = "streamable-http"
+
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    config = _read_json(config_path)
+
+    if editor == "claude-code":
+        mcp_url = url.replace("/sse", "/mcp") if url.endswith("/sse") else url
+        key = "mcpServers"
+        if key not in config:
+            config[key] = {}
+        config[key][name] = {
+            "command": "npx",
+            "args": ["-y", "mcp-remote", mcp_url],
+        }
+
+    elif editor == "cursor":
+        key = "mcpServers"
+        if key not in config:
+            config[key] = {}
+        config[key][name] = {
+            "url": url,
+            "transport": transport,
+        }
+
+    elif editor == "vscode":
+        key = "servers"
+        if key not in config:
+            config[key] = {}
+        config[key][name] = {
+            "type": transport,
+            "url": url,
+        }
+
+    elif editor == "opencode":
+        key = "mcp"
+        if key not in config:
+            config[key] = {}
+        config[key][name] = {
+            "type": "remote",
+            "url": url,
+            "enabled": True,
+        }
+
+    config_path.write_text(json.dumps(config, indent=2, ensure_ascii=False), encoding="utf-8")
+
+    editor_name = {
+        "claude-code": "Claude Code",
+        "cursor": "Cursor",
+        "vscode": "VS Code",
+        "opencode": "OpenCode",
+    }.get(editor, editor)
+
+    console.print(
+        f"[green]Servidor ligado ao {editor_name}! Por favor, reinicia o editor para aplicar as alteracoes.[/green]"
+    )
+    console.print(f"  Ficheiro: [bold]{config_path}[/bold]")
+
+    if editor == "claude-code":
+        console.print(
+            "[yellow]  Nota: O Claude Code usa 'mcp-remote' como bridge. "
+            "Certifica-te de que o Node.js esta instalado e disponivel no PATH para correr npx.[/yellow]"
+        )

r2mcp-0.1.0/r2mcp_cli/commands/logs.py

@@ -0,0 +1,66 @@
+import typer
+from rich import box
+from rich.console import Console
+from rich.table import Table
+
+from r2mcp_cli.api_client import APIClient, APIError
+from r2mcp_cli.config import get_token, validate_token
+
+console = Console()
+logs_app = typer.Typer(help="Comandos de logs")
+
+
+def _require_auth():
+    token = get_token()
+    if not token:
+        console.print(
+            "[red]ERRO: Nao autenticado. Obtém um token em https://rest2mcp.pages.dev/ e corre r2mcp login.[/red]"
+        )
+        raise typer.Exit(1)
+    ok, msg = validate_token(token)
+    if not ok:
+        console.print(f"[red]ERRO: {msg}. Obtém um token novo em https://rest2mcp.pages.dev/[/red]")
+        raise typer.Exit(1)
+
+
+@logs_app.callback(invoke_without_command=True)
+def logs_default(
+    ctx: typer.Context,
+    server_id: str = typer.Argument(..., help="ID do servidor"),
+    limit: int = typer.Option(20, "--limit", "-n", help="Número de logs a mostrar"),
+):
+    _require_auth()
+    with console.status(f"[bold green]A obter logs do servidor '{server_id}'..."):
+        try:
+            client = APIClient()
+            entries = client.get_logs(server_id, limit)
+            client.close()
+        except APIError as e:
+            console.print(f"[red]Erro: {e.detail}[/red]")
+            raise typer.Exit(1)
+        except Exception as e:
+            console.print(f"[red]Erro de conexão: {e}[/red]")
+            raise typer.Exit(1)
+
+    if not entries:
+        console.print("[yellow]Nenhum log encontrado.[/yellow]")
+        return
+
+    table = Table(box=box.SIMPLE)
+    table.add_column("ID", style="dim")
+    table.add_column("Timestamp")
+    table.add_column("Tool")
+    table.add_column("Método")
+    table.add_column("Status")
+    table.add_column("Duração (ms)")
+    for entry in entries:
+        status_style = "green" if entry.get("status_code", 0) < 400 else "red"
+        table.add_row(
+            str(entry.get("id", "")),
+            entry.get("timestamp", ""),
+            entry.get("tool_called", ""),
+            entry.get("method", "") or "-",
+            f"[{status_style}]{entry.get('status_code', '?')}[/{status_style}]",
+            f"{entry.get('duration_ms', 0):.1f}",
+        )
+    console.print(table)

r2mcp-0.1.0/r2mcp_cli/commands/servers.py

@@ -0,0 +1,261 @@
+import shutil
+import sys
+from typing import List
+
+import typer
+from rich import box
+from rich.console import Console
+from rich.table import Table
+from rich.prompt import Confirm, Prompt
+
+from r2mcp_cli.api_client import APIClient, APIError
+from r2mcp_cli.config import get_token, validate_token
+
+console = Console()
+servers_app = typer.Typer(help="Comandos de gestão de servidores")
+
+
+def _require_auth():
+    token = get_token()
+    if not token:
+        console.print(
+            "[red]ERRO: Nao autenticado. Obtém um token em https://rest2mcp.pages.dev/ e corre r2mcp login.[/red]"
+        )
+        raise typer.Exit(1)
+    ok, msg = validate_token(token)
+    if not ok:
+        console.print(f"[red]ERRO: {msg}. Obtém um token novo em https://rest2mcp.pages.dev/[/red]")
+        raise typer.Exit(1)
+
+
+@servers_app.command()
+def create(
+    name: str = typer.Option(..., "--name", "-n", help="Nome do servidor"),
+    spec_url: str = typer.Option(..., "--spec-url", "-u", help="URL do spec OpenAPI"),
+    transport: str = typer.Option("sse", "--transport", "-t", help="Transporte (sse ou http)"),
+):
+    _require_auth()
+    with console.status(f"[bold green]A criar servidor '{name}'..."):
+        try:
+            client = APIClient()
+            result = client.create_server(name, spec_url, transport)
+            client.close()
+        except APIError as e:
+            console.print(f"[red]Erro: {e.detail}[/red]")
+            raise typer.Exit(1)
+        except Exception as e:
+            console.print(f"[red]Erro de conexão: {e}[/red]")
+            raise typer.Exit(1)
+
+    table = Table(box=box.SIMPLE)
+    table.add_column("Campo", style="bold cyan")
+    table.add_column("Valor")
+    table.add_row("ID", result["server_id"])
+    table.add_row("Nome", result["name"])
+    table.add_row("Status", result["status"])
+    table.add_row("Transporte", result["transport"])
+    table.add_row("URL MCP", result["url_sse"])
+    table.add_row("API Key", result["apikey"])
+    console.print(table)
+    console.print("[green]Servidor criado![/green]")
+
+
+@servers_app.command()
+def list():
+    _require_auth()
+    console.print("[bold green]A listar servidores...[/bold green]")
+
+    try:
+        client = APIClient()
+        servers = client.list_servers()
+        client.close()
+    except APIError as e:
+        console.print(f"[red]Erro: {e.detail}[/red]")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Erro de conexão: {e}[/red]")
+        raise typer.Exit(1)
+
+    if not servers:
+        console.print("[yellow]Nenhum servidor encontrado.[/yellow]")
+        return
+
+    cols = shutil.get_terminal_size().columns
+    sys.stdout.write(f"\r{' ' * cols}\r")
+    sys.stdout.flush()
+
+    table = Table(box=box.SIMPLE)
+    table.add_column("ID", style="cyan", no_wrap=True)
+    table.add_column("Nome", no_wrap=True)
+    table.add_column("Status", no_wrap=True)
+    table.add_column("Transporte", no_wrap=True)
+    table.add_column("URL MCP", no_wrap=True)
+    for s in servers:
+        status_style = "green" if s["status"] == "active" else "red"
+        sid = s["server_id"]
+        if len(sid) > 14:
+            sid = sid[:11] + "..."
+        url = s["url_sse"]
+        url_display = url if len(url) <= 50 else url[:47] + "..."
+        table.add_row(
+            sid,
+            s["name"],
+            f"[{status_style}]{s['status']}[/{status_style}]",
+            s.get("transport", "http"),
+            url_display,
+        )
+    console.print(table)
+
+
+@servers_app.command()
+def delete(server_id: str = typer.Argument(..., help="ID do servidor")):
+    _require_auth()
+    if not Confirm.ask(f"[yellow]Tens a certeza que queres apagar o servidor '{server_id}'?[/yellow]"):
+        console.print("[yellow]Operação cancelada.[/yellow]")
+        return
+
+    with console.status(f"[bold red]A apagar servidor '{server_id}'..."):
+        try:
+            client = APIClient()
+            client.delete_server(server_id)
+            client.close()
+        except APIError as e:
+            console.print(f"[red]Erro: {e.detail}[/red]")
+            raise typer.Exit(1)
+        except Exception as e:
+            console.print(f"[red]Erro de conexão: {e}[/red]")
+            raise typer.Exit(1)
+
+    console.print(f"[green]Servidor '{server_id}' apagado.[/green]")
+
+
+@servers_app.command()
+def pause(server_id: str = typer.Argument(..., help="ID do servidor")):
+    _require_auth()
+    with console.status(f"[bold yellow]A pausar servidor '{server_id}'..."):
+        try:
+            client = APIClient()
+            client.update_server(server_id, {"status": "inactive"})
+            client.close()
+        except APIError as e:
+            console.print(f"[red]Erro: {e.detail}[/red]")
+            raise typer.Exit(1)
+        except Exception as e:
+            console.print(f"[red]Erro de conexão: {e}[/red]")
+            raise typer.Exit(1)
+
+    console.print(f"[green]Servidor '{server_id}' pausado.[/green]")
+
+
+@servers_app.command()
+def resume(server_id: str = typer.Argument(..., help="ID do servidor")):
+    _require_auth()
+    with console.status(f"[bold green]A retomar servidor '{server_id}'..."):
+        try:
+            client = APIClient()
+            client.update_server(server_id, {"status": "active"})
+            client.close()
+        except APIError as e:
+            console.print(f"[red]Erro: {e.detail}[/red]")
+            raise typer.Exit(1)
+        except Exception as e:
+            console.print(f"[red]Erro de conexão: {e}[/red]")
+            raise typer.Exit(1)
+
+    console.print(f"[green]Servidor '{server_id}' retomado.[/green]")
+
+
+@servers_app.command()
+def credentials(
+    server_id: str = typer.Argument(..., help="ID do servidor"),
+    key_value: List[str] = typer.Option(
+        [], "--set", "-s", help="Par chave=valor (ex: -s username=admin -s password=123456)"
+    ),
+):
+    _require_auth()
+    client = APIClient()
+
+    if key_value:
+        creds = {}
+        for kv in key_value:
+            if "=" not in kv:
+                console.print(f"[red]Formato invalido: '{kv}'. Use chave=valor.[/red]")
+                raise typer.Exit(1)
+            k, v = kv.split("=", 1)
+            creds[k] = v
+        try:
+            result = client.set_credentials(server_id, creds)
+            client.close()
+            console.print(f"[green]Credenciais salvas para '{server_id}'.[/green]")
+        except APIError as e:
+            client.close()
+            console.print(f"[red]Erro: {e.detail}[/red]")
+            raise typer.Exit(1)
+    else:
+        try:
+            info = client.check_credentials(server_id)
+            client.close()
+        except APIError as e:
+            client.close()
+            console.print(f"[red]Erro: {e.detail}[/red]")
+            raise typer.Exit(1)
+        if info.get("has_credentials"):
+            console.print(f"[green]Servidor '{server_id}' tem credenciais configuradas.[/green]")
+        else:
+            console.print(f"[yellow]Servidor '{server_id}' nao tem credenciais configuradas.[/yellow]")
+
+
+PASSWORD_KEYS = {"password", "senha", "pwd", "pass", "secret", "palavra-passe", "passwd"}
+
+
+@servers_app.command()
+def login(
+    server_id: str = typer.Argument(..., help="ID do servidor"),
+):
+    _require_auth()
+    client = APIClient()
+    try:
+        auth_info = client.get_auth_status(server_id)
+    except APIError as e:
+        client.close()
+        console.print(f"[red]Erro: {e.detail}[/red]")
+        raise typer.Exit(1)
+
+    fields = auth_info.get("required_fields", [])
+    if not fields:
+        console.print("[yellow]Este servidor nao requer autenticacao.[/yellow]")
+        client.close()
+        return
+
+    if auth_info.get("authenticated"):
+        console.print("[green]Servidor ja esta autenticado.[/green]")
+        client.close()
+        return
+
+    console.print(f"[bold]Login no servidor {server_id}[/bold]")
+    console.print(f"[dim]Campos necessarios: {', '.join(fields)}[/dim]")
+
+    values = {}
+    for field in fields:
+        is_password = field.lower() in PASSWORD_KEYS
+        values[field] = Prompt.ask(
+            field,
+            password=is_password,
+        )
+
+    try:
+        result = client.login_server(server_id, values)
+        client.close()
+        if result.get("token"):
+            console.print("[green]Autenticado com sucesso![/green]")
+        else:
+            console.print("[red]Resposta inesperada do servidor.[/red]")
+    except APIError as e:
+        client.close()
+        if "Internal Server Error" in e.detail or e.status_code == 500:
+            console.print(
+                "[red]API do servidor nao esta acessivel ou recusou o login. Verifica se a API esta online.[/red]"
+            )
+        else:
+            console.print(f"[red]Erro no login: {e.detail}[/red]")
+        raise typer.Exit(1)

r2mcp-0.1.0/r2mcp_cli/commands/tools.py

@@ -0,0 +1,112 @@
+import json
+from typing import List, Optional
+
+import typer
+from rich import box
+from rich.console import Console
+from rich.table import Table
+from rich.syntax import Syntax
+
+from r2mcp_cli.api_client import APIClient, APIError
+from r2mcp_cli.config import get_token, validate_token
+
+console = Console()
+tools_app = typer.Typer(help="Comandos de interação com ferramentas")
+
+
+def _require_auth():
+    token = get_token()
+    if not token:
+        console.print(
+            "[red]ERRO: Nao autenticado. Obtém um token em https://rest2mcp.pages.dev/ e corre r2mcp login.[/red]"
+        )
+        raise typer.Exit(1)
+    ok, msg = validate_token(token)
+    if not ok:
+        console.print(f"[red]ERRO: {msg}. Obtém um token novo em https://rest2mcp.pages.dev/[/red]")
+        raise typer.Exit(1)
+
+
+@tools_app.command()
+def list(
+    server_id: str = typer.Argument(..., help="ID do servidor"),
+):
+    _require_auth()
+    with console.status(f"[bold green]A listar tools do servidor '{server_id}'..."):
+        try:
+            client = APIClient()
+            tools = client.list_tools(server_id)
+            client.close()
+        except APIError as e:
+            console.print(f"[red]Erro: {e.detail}[/red]")
+            raise typer.Exit(1)
+        except Exception as e:
+            console.print(f"[red]Erro de conexão: {e}[/red]")
+            raise typer.Exit(1)
+
+    if not tools:
+        console.print("[yellow]Nenhuma tool encontrada.[/yellow]")
+        return
+
+    table = Table(box=box.SIMPLE)
+    table.add_column("#", style="dim")
+    table.add_column("Nome", style="cyan")
+    table.add_column("Descrição")
+    for i, t in enumerate(tools, 1):
+        desc = t.get("description", "") or ""
+        if len(desc) > 80:
+            desc = desc[:77] + "..."
+        table.add_row(str(i), t.get("name", "?"), desc)
+    console.print(table)
+
+
+@tools_app.command()
+def call(
+    server_id: str = typer.Argument(..., help="ID do servidor"),
+    tool_name: str = typer.Argument(..., help="Nome da tool"),
+    args: Optional[str] = typer.Option(None, "--args", help="JSON string de argumentos"),
+    arg: List[str] = typer.Option([], "-A", help="Argumentos key=value (pode usar múltiplas vezes)"),
+):
+    _require_auth()
+
+    arguments = {}
+    if args:
+        try:
+            arguments = json.loads(args)
+        except json.JSONDecodeError as e:
+            console.print(f"[red]JSON inválido em --args: {e}[/red]")
+            raise typer.Exit(1)
+    elif arg:
+        for kv in arg:
+            if "=" not in kv:
+                console.print(f"[red]Formato inválido: '{kv}'. Esperado key=value.[/red]")
+                raise typer.Exit(1)
+            key, val = kv.split("=", 1)
+            arguments[key] = val
+
+    with console.status(f"[bold green]A chamar tool '{tool_name}'..."):
+        try:
+            client = APIClient()
+            result = client.call_tool(server_id, tool_name, arguments)
+            client.close()
+        except APIError as e:
+            console.print(f"[red]Erro: {e.detail}[/red]")
+            raise typer.Exit(1)
+        except Exception as e:
+            console.print(f"[red]Erro de conexão: {e}[/red]")
+            raise typer.Exit(1)
+
+    if result.get("isError"):
+        console.print("[red]A tool retornou um erro:[/red]")
+
+    for content in result.get("content", []):
+        ctype = content.get("type", "")
+        text = content.get("text", "")
+        if ctype == "text":
+            console.print(text)
+        elif ctype in ("json", "json_object"):
+            parsed = json.loads(text) if isinstance(text, str) else text
+            syntax = Syntax(json.dumps(parsed, indent=2), "json", theme="monokai")
+            console.print(syntax)
+        else:
+            console.print(f"[{ctype}] {text}")

r2mcp-0.1.0/r2mcp_cli/config.py

@@ -0,0 +1,67 @@
+import base64
+import json
+import time
+from typing import Optional
+from pathlib import Path
+
+CONFIG_DIR = Path.home() / ".r2mcp"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+DEFAULT_BASE_URL = "http://localhost:8080"
+
+
+def _ensure_config_dir():
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def load_config() -> dict:
+    _ensure_config_dir()
+    if CONFIG_FILE.exists():
+        try:
+            return json.loads(CONFIG_FILE.read_text())
+        except (json.JSONDecodeError, OSError):
+            return {}
+    return {}
+
+
+def save_config(config: dict):
+    _ensure_config_dir()
+    CONFIG_FILE.write_text(json.dumps(config, indent=2))
+
+
+def get_token() -> Optional[str]:
+    return load_config().get("token")
+
+
+def set_token(token: str):
+    cfg = load_config()
+    cfg["token"] = token
+    save_config(cfg)
+
+
+def clear_token():
+    cfg = load_config()
+    cfg.pop("token", None)
+    save_config(cfg)
+
+
+def get_base_url() -> str:
+    return load_config().get("base_url", DEFAULT_BASE_URL)
+
+
+def set_base_url(url: str):
+    cfg = load_config()
+    cfg["base_url"] = url.rstrip("/")
+    save_config(cfg)
+
+
+def validate_token(token: str) -> tuple[bool, str]:
+    try:
+        payload_b64 = token.split(".")[1]
+        payload_b64 += "=" * (4 - len(payload_b64) % 4)
+        payload = json.loads(base64.urlsafe_b64decode(payload_b64))
+        exp = payload.get("exp")
+        if exp is not None and time.time() > exp:
+            return False, "Token expirado. Faz r2mcp login primeiro."
+        return True, ""
+    except (IndexError, ValueError, json.JSONDecodeError):
+        return False, "Token invalido. Faz r2mcp login primeiro."

r2mcp-0.1.0/r2mcp_cli/main.py

@@ -0,0 +1,34 @@
+import typer
+from rich.console import Console
+
+from r2mcp_cli.commands.auth import login, logout, me, config_app
+from r2mcp_cli.commands.servers import servers_app
+from r2mcp_cli.commands.tools import tools_app
+from r2mcp_cli.commands.link import link_app
+from r2mcp_cli.commands.logs import logs_app
+
+console = Console()
+
+app = typer.Typer(
+    name="r2mcp",
+    help="CLI para gestão de servidores MCP via rest2mcp gateway",
+    no_args_is_help=True,
+)
+
+app.command()(login)
+app.command()(logout)
+app.command()(me)
+app.add_typer(config_app, name="config", help="Gerir configuração local")
+app.add_typer(servers_app, name="servers", help="Gerir servidores MCP")
+app.add_typer(tools_app, name="tools", help="Interagir com ferramentas MCP")
+app.add_typer(link_app, name="link", help="Ligar servidor a editor IA")
+app.add_typer(logs_app, name="logs", help="Ver logs de servidores")
+
+
+@app.callback()
+def callback():
+    pass
+
+
+if __name__ == "__main__":
+    app()

r2mcp-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+