restapi-mcp-server 0.0.1__py3-none-any.whl

restapi_mcp_server/__init__.py

@@ -0,0 +1,4 @@
+"""
+RestAPI MCP Server package.
+"""
+__version__ = "0.0.1"

restapi_mcp_server/__main__.py

@@ -0,0 +1,328 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.exceptions import RequestValidationError
+from .src.api.router import api_v001
+from .src.constants import COMMON
+import uvicorn
+import os
+from .src.utils.logger import setup_logging
+from fastapi import Request
+from mcp.server.fastmcp import FastMCP
+from typing import Dict, List, Any
+import httpx
+import asyncio
+import threading
+from .src.utils.env import load_common_from_env
+from pathlib import Path
+from http.server import ThreadingHTTPServer, BaseHTTPRequestHandler
+
+logger = setup_logging()
+
+# Create the ASGI app at module scope so Uvicorn can import it via string path
+app = FastAPI(
+    title="Rest API Orchestrator",
+    version="0.0.1",
+    docs_url="/api/docs",
+    redoc_url="/api/redoc",
+    openapi_url="/api/openapi.json",
+)
+
+# CORS: allow requests from any origin (any IP/host and any port) for all routes.
+#
+# Notes:
+# - allow_origins=["*"] is sufficient to allow all hosts/ports.
+# - If allow_credentials=True, FastAPI/starlette will NOT allow "*"; it must be
+#   an explicit list. We default credentials off for a true allow-all stance.
+# - We also allow all methods/headers and expose all headers.
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=False,
+    allow_methods=["*"],
+    allow_headers=["*"],
+    expose_headers=["*"],
+    max_age=86400,
+)
+app.include_router(api_v001)
+
+# Guard error logging middleware to avoid double-send issues under certain ASGI flows
+if os.getenv("ENABLE_ERROR_LOG_MW", "0").lower() in ("1", "true", "yes", "on"):
+    @app.middleware("http")
+    async def error_logging_middleware(request: Request, call_next):
+        try:
+            response = await call_next(request)
+        except Exception:
+            logger.exception("Unhandled exception: %s %s", request.method, request.url.path)
+            raise
+        if response.status_code >= 400:
+            logger.error("Request failed: %s %s -> %d", request.method, request.url.path, response.status_code)
+        return response
+
+def startAppServer():
+    host = COMMON.HOST
+    port = COMMON.API_PORT
+    log_level = COMMON.log_level
+
+    # Use an import string that points to this module's app object
+    import_string = "restapi_mcp_server.__main__:app"
+
+    # Disable reload by default in container to avoid multi-process duplication issues
+    # Enable via UVICORN_RELOAD=1 if needed for local dev
+    reload_flag = os.getenv("UVICORN_RELOAD", "0").lower() in ("1", "true", "yes", "on")
+
+    uvicorn.run(
+        import_string,
+        host=host,
+        port=port,
+        log_level=log_level,
+        reload=reload_flag,
+        reload_dirs=["."] if reload_flag else None,
+        proxy_headers=False,
+        workers=1,
+    )
+
+
+def startStaticIndexServer():
+    """Serve only index.html on a dedicated port (default :5500).
+
+    This keeps the FastAPI/Uvicorn port unchanged while allowing a simple UI server
+    suitable for local use and Docker.
+    """
+
+    ui_host = os.getenv("UI_HOST", "0.0.0.0")
+    ui_port = int(os.getenv("UI_PORT", "5500"))
+
+    index_path = Path(__file__).resolve().parent / "static" / "index.html"
+    if not index_path.exists():
+        logger.warning("[UI] index.html not found at %s; UI server will not start", index_path)
+        return
+
+    index_bytes = index_path.read_bytes()
+
+    class _IndexOnlyHandler(BaseHTTPRequestHandler):
+        def do_GET(self):  # noqa: N802 (stdlib naming)
+            # Serve index for / or /index.html; 404 for everything else.
+            if self.path in ("/", "/index.html"):
+                self.send_response(200)
+                self.send_header("Content-Type", "text/html; charset=utf-8")
+                self.send_header("Content-Length", str(len(index_bytes)))
+                self.end_headers()
+                self.wfile.write(index_bytes)
+                return
+
+            self.send_response(404)
+            self.send_header("Content-Type", "text/plain; charset=utf-8")
+            self.end_headers()
+            self.wfile.write(b"Not Found")
+
+        def log_message(self, format, *args):  # noqa: N802 (stdlib naming)
+            # Route http.server logs through our logger (info level)
+            logger.info("[UI] %s - %s", self.address_string(), format % args)
+
+    def _run():
+        try:
+            httpd = ThreadingHTTPServer((ui_host, ui_port), _IndexOnlyHandler)
+            logger.info("[UI] Serving %s on http://%s:%d", index_path, ui_host, ui_port)
+            httpd.serve_forever()
+        except OSError as e:
+            logger.error("[UI] Failed to start UI server on %s:%d: %s", ui_host, ui_port, e)
+        except Exception:
+            logger.exception("[UI] UI server crashed")
+
+    threading.Thread(target=_run, name="ui-5500", daemon=True).start()
+
+def createMCPServerWithTools():
+
+    mcp_host: str = COMMON.HOST
+    mcp_port: int = COMMON.MCP_API_PORT
+    # Allow overriding the orchestrator base URL (default stays local for dev)
+    # Set env var RESTAPI_ORCHESTRATOR_BASE (or ORCHESTRATOR_BASE) to target a remote host
+    API_BASE: str = os.getenv("RESTAPI_ORCHESTRATOR_BASE") or f"http://127.0.0.1:{COMMON.API_PORT}"
+    logger.info(f"[MCP] Orchestrator base: {API_BASE}")
+    mcp = FastMCP("restapi_orchestrator_tools", host=mcp_host, port=mcp_port)
+
+    @mcp.tool()
+    def createSession() -> Dict[str, Any]:
+        """Create a new session id.
+        Returns: { "session": string }
+        """
+        with httpx.Client(timeout=30.0) as client:
+            r = client.post(f"{API_BASE}/api/v001/session/createSession")
+            r.raise_for_status()
+            return r.json()
+
+    @mcp.tool()
+    def createEnvironmentVariables(items: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Upsert environment variables via REST API.
+        
+        Endpoint: PUT /api/v001/variables/upsertEnvironmentVariable
+        Input: items: list of { "environment": str, "variable": str, "value": Any }
+        Returns: list of upserted items (echoed from API)
+        """
+        results: List[Dict[str, Any]] = []
+        with httpx.Client(timeout=30.0) as client:
+            for it in items:
+                r = client.put(f"{API_BASE}/api/v001/variables/upsertEnvironmentVariable", json=it)
+                r.raise_for_status()
+                results.append(r.json())
+        return results
+
+    @mcp.tool()
+    def upsertEnvironmentVariable(environment: str, variable: str, value: Any) -> Dict[str, Any]:
+        """Upsert a single environment variable via REST API.
+        
+        Endpoint: PUT /api/v001/variables/upsertEnvironmentVariable
+        Inputs:
+          - environment: target environment name
+          - variable: variable name
+          - value: variable value (any JSON-serializable type)
+        Returns: { environment, variable, value }
+        """
+        payload: Dict[str, Any] = {
+            "environment": environment,
+            "variable": variable,
+            "value": value,
+        }
+        with httpx.Client(timeout=30.0) as client:
+            r = client.put(
+                f"{API_BASE}/api/v001/variables/upsertEnvironmentVariable",
+                json=payload,
+            )
+            r.raise_for_status()
+            return r.json()
+
+    @mcp.tool()
+    def listAllEnvironmentVariables(environment: str) -> List[Dict[str, Any]]:
+        """List all variables for the given environment.
+        Returns: array of { environment, variable, value }
+        """
+        with httpx.Client(timeout=30.0) as client:
+            r = client.get(
+                f"{API_BASE}/api/v001/variables/listAllEnvironmentVariables", params={"environment": environment}
+            )
+            r.raise_for_status()
+            return r.json()
+
+    @mcp.tool()
+    def listSpecificEnvironmentVariable(environment: str, variable: str) -> List[Dict[str, Any]]:
+        """Get a specific environment variable.
+        Returns: { environment, variable, value }
+        """
+        with httpx.Client(timeout=30.0) as client:
+            r = client.get(
+                f"{API_BASE}/api/v001/variables/listSpecificVariableByEnvironment",
+                params={"environment": environment, "variable": variable},
+            )
+            r.raise_for_status()
+            return r.json()
+
+    @mcp.tool()
+    def deleteAllByEnvironment(environment: str) -> Dict[str, Any]:
+        """Delete all variables for the given environment via REST API.
+
+        Endpoint: DELETE /api/v001/variables/deleteAllByEnvironment
+        Returns: { environment, deletedCount }
+        """
+        with httpx.Client(timeout=30.0) as client:
+            r = client.delete(
+                f"{API_BASE}/api/v001/variables/deleteAllByEnvironment",
+                params={"environment": environment},
+            )
+            r.raise_for_status()
+            return r.json()
+
+    @mcp.tool()
+    def health() -> Dict[str, Any]:
+        """Check API health.
+        
+        Endpoint: GET /api/v001/health
+        Returns: {"status": "ok"} on healthy server.
+        """
+        with httpx.Client(timeout=10.0) as client:
+            r = client.get(f"{API_BASE}/api/v001/health")
+            r.raise_for_status()
+            return r.json()
+
+    @mcp.tool()
+    def createRestAPICall(
+        method: str,
+        url: str,
+        action: str,
+        environment: str,
+        session: str,
+        request_headers: Dict[str, Any] | None = None,
+        request_body: Any | None = None,
+        request_form_data: Dict[str, Any] | None = None,
+        request_files: List[Dict[str, Any]] | None = None,
+        pre_script: Any | None = None,
+        post_script: Any | None = None,
+        debug: bool | None = None,
+    ) -> Dict[str, Any]:
+        """Call the RestAPI Orchestrator HTTP endpoint.
+        
+        Endpoint: POST /api/v001/restapi/call
+        
+        Inputs:
+        - method: HTTP method (GET, POST, PUT, PATCH, DELETE)
+        - url: Target URL (supports variable/base64/jq interpolation server-side)
+        - action: Logical action name for transaction logging
+        - environment: Environment name
+        - session: Session identifier
+        - request_headers: Optional headers map (values may use interpolation syntax)
+        - request_body: Optional JSON body (values may use interpolation syntax)
+        - request_form_data: Optional form fields map for x-www-form-urlencoded or multipart requests
+        - request_files: Optional list of file parts. Each item: {field_name, filename, content_type?, content}
+        - pre_script: Reserved (not used currently)
+        - post_script: Optional dict of {"{{VARIABLE_NAME}}": "expression"}; evaluated on 2xx/3xx status
+        - debug: Optional flag
+        
+        Returns: { response_status, response_headers, response_body }
+        """
+        payload: Dict[str, Any] = {
+            "method": method,
+            "url": url,
+            "action": action,
+            "environment": environment,
+            "session": session,
+        }
+        if request_headers is not None:
+            payload["request_headers"] = request_headers
+        if request_body is not None:
+            payload["request_body"] = request_body
+        if request_form_data is not None:
+            payload["request_form_data"] = request_form_data
+        if request_files is not None:
+            payload["request_files"] = request_files
+        if pre_script is not None:
+            payload["pre_script"] = pre_script
+        if post_script is not None:
+            payload["post_script"] = post_script
+        if debug is not None:
+            payload["debug"] = bool(debug)
+
+        with httpx.Client(timeout=60.0) as client:
+            r = client.post(f"{API_BASE}/api/v001/restapi/call", json=payload)
+            r.raise_for_status()
+            return r.json()
+
+    def _run_mcp_in_thread():
+        try:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            mcp.run(transport="sse")
+        except Exception as e:
+            print(f"[MCP] MCP server thread exited: {e}")
+
+    thread = threading.Thread(target=_run_mcp_in_thread, name="mcp-sse", daemon=True)
+    thread.start()
+
+def main():
+    load_common_from_env()
+    global logger
+    logger = setup_logging()
+    startStaticIndexServer()
+    createMCPServerWithTools()
+    startAppServer()
+
+if __name__ == "__main__":
+    main()

restapi_mcp_server/src/api/router.py

@@ -0,0 +1,17 @@
+from fastapi import APIRouter
+from .v0_0_1.routes.bas64interpolationRoute import router as b64_router
+from .v0_0_1.routes.sessionRoute import router as session_router
+from .v0_0_1.routes.jqRoute import router as jq_router
+from .v0_0_1.routes.variablesRoute import router as variable_router
+from .v0_0_1.routes.transactionRoute import router as transaction_router
+from .v0_0_1.routes.restapiRoute import router as restapi_router
+from .v0_0_1.routes.healthRouter import router as health_router
+
+api_v001 = APIRouter(prefix="/api/v001")
+api_v001.include_router(health_router)
+api_v001.include_router(b64_router)
+api_v001.include_router(session_router)
+api_v001.include_router(jq_router)
+api_v001.include_router(variable_router)
+api_v001.include_router(transaction_router)
+api_v001.include_router(restapi_router)

restapi_mcp_server/src/api/v0_0_1/__init__.py

@@ -0,0 +1,7 @@
+"""
+API version 0.0.1 (import-safe package v0_0_1)
+
+This file marks the directory as a Python package to ensure reliable imports:
+from .v0_0_1.routes.bas64interpolationRoute import router
+"""
+__all__ = []

restapi_mcp_server/src/api/v0_0_1/routes/bas64interpolationRoute.py

@@ -0,0 +1,57 @@
+"""
+Base64 encode/decode routes.
+
+Endpoints:
+- POST /base64/encode
+    Encode plain text to Base64.
+
+- POST /base64/decode
+    Decode a Base64-encoded string to plain text.
+"""
+from fastapi import APIRouter, HTTPException
+from ....models.bas64interpolationSchema import (
+    Base64EncodeIn,
+    Base64EncodeOut,
+    Base64DecodeIn,
+    Base64DecodeOut,
+)
+from ....utils.bas64interpolation import encode_base64, decode_base64
+
+# Router for Base64 operations
+router = APIRouter(prefix="/base64", tags=["Base64"])
+
+@router.post("/encode", response_model=Base64EncodeOut)
+def base64_encode(payload: Base64EncodeIn):
+    """
+    Encode plain text to a Base64 string.
+
+    Request body (Base64EncodeIn):
+      - text: Plain text to encode.
+
+    Returns:
+      Base64EncodeOut with 'encoded' containing the Base64 string.
+    """
+    try:
+        base64_encoded_str = encode_base64(text=payload.text)
+        response_payload = Base64EncodeOut(encoded=base64_encoded_str)
+        return response_payload
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@router.post("/decode", response_model=Base64DecodeOut)
+def base64_decode(payload: Base64DecodeIn):
+    """
+    Decode a Base64 string to plain text.
+
+    Request body (Base64DecodeIn):
+      - encodedString: Base64-encoded string to decode.
+
+    Returns:
+      Base64DecodeOut with 'text' containing the decoded plain text.
+    """
+    try:
+        base64_decoded_str = decode_base64(b64_text=payload.encodedString)
+        response_payload = Base64DecodeOut(text=base64_decoded_str)
+        return response_payload
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))

restapi_mcp_server/src/api/v0_0_1/routes/healthRouter.py

@@ -0,0 +1,7 @@
+from fastapi import APIRouter
+
+router = APIRouter(tags=["Health"])
+
+@router.get("/health")
+def health_env():
+    return {"status": "ok"}

restapi_mcp_server/src/api/v0_0_1/routes/jqRoute.py

@@ -0,0 +1,29 @@
+"""
+JQ expression evaluation routes.
+
+Endpoints:
+- POST /jq/eval
+    Evaluate a JQ expression against supplied JSON input.
+"""
+from fastapi import APIRouter, HTTPException
+from ....utils import jqinterpolation
+from ....models.jqSchema import JQExpressionIn, JQExpressionOut
+
+router = APIRouter(prefix="/jq", tags=["JQ"])
+
+@router.post("/eval", response_model=JQExpressionOut)
+def jq_expression_evaluation(payload: JQExpressionIn):
+    """
+    Evaluate a JQ expression against provided JSON input.
+
+    Request body (JQExpressionIn):
+      - expression: JQ expression string to evaluate.
+      - data: JSON input object/array the expression applies to.
+
+    Returns:
+      JQExpressionOut: Pydantic model with 'result' containing the evaluation output.
+    """
+    try:
+        return JQExpressionOut(result=jqinterpolation.jqinterpolate(expression=payload.expression,json_input=payload.data))
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))