golf-mcp 0.2.9__py3-none-any.whl → 0.2.11__py3-none-any.whl

golf/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.2.9"
+__version__ = "0.2.11"
 
 # Import endpoints with fallback for dev mode
 try:

golf/core/builder.py

@@ -581,6 +581,201 @@ class CodeGenerator:
             # Default to older behavior for safety
             return False
 
+    def _generate_startup_section(self, project_path: Path) -> list[str]:
+        """Generate code section for startup.py execution during server runtime."""
+        startup_path = project_path / "startup.py"
+
+        if not startup_path.exists():
+            return []
+
+        return [
+            "",
+            "# Execute startup script for loading secrets and initialization",
+            "import importlib.util",
+            "import sys",
+            "import os",
+            "from pathlib import Path",
+            "",
+            "# Look for startup.py in the same directory as this server.py",
+            "startup_path = Path(__file__).parent / 'startup.py'",
+            "if startup_path.exists():",
+            "    try:",
+            "        # Save original environment for restoration",
+            "        try:",
+            "            original_dir = os.getcwd()",
+            "        except (FileNotFoundError, OSError):",
+            "            # Use server directory as fallback",
+            "            original_dir = str(Path(__file__).parent)",
+            "            os.chdir(original_dir)",
+            "        original_path = sys.path.copy()",
+            "        ",
+            "        # Set context for startup script execution",
+            "        script_dir = str(startup_path.parent)",
+            "        os.chdir(script_dir)",
+            "        sys.path.insert(0, script_dir)",
+            "        ",
+            "        # Debug output for startup script development",
+            "        if os.environ.get('GOLF_DEBUG'):",
+            "            print(f'Executing startup script: {startup_path}')",
+            "            print(f'Working directory: {os.getcwd()}')",
+            "            print(f'Python path: {sys.path[:3]}...')",  # Show first 3 entries
+            "        ",
+            "        # Load and execute startup script",
+            "        spec = importlib.util.spec_from_file_location('startup', startup_path)",
+            "        if spec and spec.loader:",
+            "            startup_module = importlib.util.module_from_spec(spec)",
+            "            spec.loader.exec_module(startup_module)",
+            "        else:",
+            "            print('Warning: Could not load startup.py', file=sys.stderr)",
+            "        ",
+            "    except Exception as e:",
+            "        import traceback",
+            "        print(f'Warning: Startup script execution failed: {e}', file=sys.stderr)",
+            "        print(traceback.format_exc(), file=sys.stderr)",
+            "        # Continue server startup despite script failure",
+            "        ",
+            "    finally:",
+            "        # Always restore original environment",
+            "        try:",
+            "            os.chdir(original_dir)",
+            "            sys.path[:] = original_path",
+            "        except Exception:",
+            "            # If directory restoration fails, at least fix the path",
+            "            sys.path[:] = original_path",
+            "",
+        ]
+
+    def _generate_readiness_section(self, project_path: Path) -> list[str]:
+        """Generate code section for readiness.py execution during server runtime."""
+        readiness_path = project_path / "readiness.py"
+
+        if not readiness_path.exists():
+            # Only generate default readiness if health checks are explicitly enabled
+            if not self.settings.health_check_enabled:
+                return []
+            return [
+                "# Default readiness check - no custom readiness.py found",
+                "@mcp.custom_route('/ready', methods=[\"GET\"])",
+                "async def readiness_check(request: Request) -> JSONResponse:",
+                '    """Readiness check endpoint for Kubernetes and load balancers."""',
+                '    return JSONResponse({"status": "pass"}, status_code=200)',
+                "",
+            ]
+
+        return [
+            "# Custom readiness check from readiness.py",
+            "from readiness import check as readiness_check_func",
+            "@mcp.custom_route('/ready', methods=[\"GET\"])",
+            "async def readiness_check(request: Request):",
+            '    """Readiness check endpoint for Kubernetes and load balancers."""',
+            "    result = readiness_check_func()",
+            "    if isinstance(result, dict):",
+            "        return JSONResponse(result)",
+            "    return result",
+            "",
+        ]
+
+    def _generate_health_section(self, project_path: Path) -> list[str]:
+        """Generate code section for health.py execution during server runtime."""
+        health_path = project_path / "health.py"
+
+        if not health_path.exists():
+            # Check if legacy health configuration is used
+            if self.settings.health_check_enabled:
+                return [
+                    "# Legacy health check configuration (deprecated)",
+                    "@mcp.custom_route('" + self.settings.health_check_path + '\', methods=["GET"])',
+                    "async def health_check(request: Request) -> PlainTextResponse:",
+                    '    """Health check endpoint for Kubernetes and load balancers."""',
+                    f'    return PlainTextResponse("{self.settings.health_check_response}")',
+                    "",
+                ]
+            else:
+                # If health checks are disabled, return empty (no default health check)
+                return []
+
+        return [
+            "# Custom health check from health.py",
+            "from health import check as health_check_func",
+            "@mcp.custom_route('/health', methods=[\"GET\"])",
+            "async def health_check(request: Request):",
+            '    """Health check endpoint for Kubernetes and load balancers."""',
+            "    result = health_check_func()",
+            "    if isinstance(result, dict):",
+            "        return JSONResponse(result)",
+            "    return result",
+            "",
+        ]
+
+    def _generate_check_function_helper(self) -> list[str]:
+        """Generate helper function to call custom check functions."""
+        return [
+            "# Helper function to call custom check functions",
+            "async def _call_check_function(check_type: str) -> JSONResponse:",
+            '    """Call custom check function and handle errors gracefully."""',
+            "    import importlib.util",
+            "    import traceback",
+            "    from pathlib import Path",
+            "    from datetime import datetime",
+            "    ",
+            "    try:",
+            "        # Load the custom check module",
+            "        module_path = Path(__file__).parent / f'{check_type}.py'",
+            "        if not module_path.exists():",
+            '            return JSONResponse({"status": "pass"}, status_code=200)',
+            "        ",
+            "        spec = importlib.util.spec_from_file_location(f'{check_type}_check', module_path)",
+            "        if spec and spec.loader:",
+            "            module = importlib.util.module_from_spec(spec)",
+            "            spec.loader.exec_module(module)",
+            "            ",
+            "            # Call the check function if it exists",
+            "            if hasattr(module, 'check'):",
+            "                result = module.check()",
+            "                ",
+            "                # Handle different return types",
+            "                if isinstance(result, dict):",
+            "                    # User returned structured response",
+            "                    status_code = result.get('status_code', 200)",
+            "                    response_data = {k: v for k, v in result.items() if k != 'status_code'}",
+            "                elif isinstance(result, bool):",
+            "                    # User returned simple boolean",
+            "                    status_code = 200 if result else 503",
+            "                    response_data = {",
+            '                        "status": "pass" if result else "fail",',
+            '                        "timestamp": datetime.utcnow().isoformat()',
+            "                    }",
+            "                elif result is None:",
+            "                    # User returned nothing - assume success",
+            "                    status_code = 200",
+            '                    response_data = {"status": "pass"}',
+            "                else:",
+            "                    # User returned something else - treat as success message",
+            "                    status_code = 200",
+            "                    response_data = {",
+            '                        "status": "pass",',
+            '                        "message": str(result)',
+            "                    }",
+            "                ",
+            "                return JSONResponse(response_data, status_code=status_code)",
+            "            else:",
+            "                return JSONResponse(",
+            '                    {"status": "fail", "error": f"No check() function found in {check_type}.py"},',
+            "                    status_code=503",
+            "                )",
+            "    ",
+            "    except Exception as e:",
+            "        # Log error and return failure response",
+            "        import sys",
+            '        print(f"Error calling {check_type} check function: {e}", file=sys.stderr)',
+            "        print(traceback.format_exc(), file=sys.stderr)",
+            "        return JSONResponse({",
+            '            "status": "fail",',
+            '            "error": f"Error calling {check_type} check function: {str(e)}"',
+            "        }, status_code=503)",
+            "",
+        ]
+
     def _generate_server(self) -> None:
         """Generate the main server entry point."""
         server_file = self.output_dir / "server.py"
@@ -636,14 +831,31 @@ class CodeGenerator:
             imports.extend(generate_metrics_instrumentation())
             imports.extend(generate_session_tracking())
 
-        # Add health check imports if enabled
-        if self.settings.health_check_enabled:
-            imports.extend(
-                [
-                    "from starlette.requests import Request",
-                    "from starlette.responses import PlainTextResponse",
-                ]
-            )
+        # Add health check imports only when we generate default endpoints
+        readiness_exists = (self.project_path / "readiness.py").exists()
+        health_exists = (self.project_path / "health.py").exists()
+
+        # Only import starlette when we generate default endpoints (not when custom files exist)
+        will_generate_default_readiness = not readiness_exists and self.settings.health_check_enabled
+        will_generate_default_health = not health_exists and self.settings.health_check_enabled
+
+        if will_generate_default_readiness or will_generate_default_health:
+            imports.append("from starlette.requests import Request")
+
+            # Determine response types needed for default endpoints
+            response_types = []
+            if will_generate_default_readiness:
+                response_types.append("JSONResponse")
+            if will_generate_default_health:
+                response_types.append("PlainTextResponse")
+
+            if response_types:
+                imports.append(f"from starlette.responses import {', '.join(response_types)}")
+
+        # Import Request and JSONResponse for custom check routes (they need both)
+        elif readiness_exists or health_exists:
+            imports.append("from starlette.requests import Request")
+            imports.append("from starlette.responses import JSONResponse")
 
         # Get transport-specific configuration
         transport_config = self._get_transport_config(self.settings.transport)
@@ -935,6 +1147,9 @@ class CodeGenerator:
             "",
         ]
 
+        # Generate startup section
+        startup_section = self._generate_startup_section(self.project_path)
+
         # OpenTelemetry setup code will be handled through imports and lifespan
 
         # Add auth setup code if auth is configured
@@ -1132,32 +1347,30 @@ class CodeGenerator:
 
             metrics_route_code = generate_metrics_route(self.settings.metrics_path)
 
-        # Add health check route if enabled
-        health_check_code = []
-        if self.settings.health_check_enabled:
-            health_check_code = [
-                "# Add health check route",
-                "@mcp.custom_route('" + self.settings.health_check_path + '\', methods=["GET"])',
-                "async def health_check(request: Request) -> PlainTextResponse:",
-                '    """Health check endpoint for Kubernetes and load balancers."""',
-                (f'    return PlainTextResponse("{self.settings.health_check_response}")'),
-                "",
-            ]
+        # Generate readiness and health check sections
+        readiness_section = self._generate_readiness_section(self.project_path)
+        health_section = self._generate_health_section(self.project_path)
+
+        # No longer need the check helper function since we use direct imports
+        check_helper_section = []
 
         # Combine all sections
-        # Order: imports, env_section, auth_setup, server_code (mcp init),
+        # Order: imports, env_section, startup_section, auth_setup, server_code (mcp init),
         # early_telemetry_init, early_metrics_init, component_registrations,
-        # metrics_route_code, health_check_code, main_code (run block)
+        # metrics_route_code, check_helper_section, readiness_section, health_section, main_code (run block)
         code = "\n".join(
             imports
             + env_section
+            + startup_section
             + auth_setup_code
             + server_code_lines
             + early_telemetry_init
             + early_metrics_init
             + component_registrations
             + metrics_route_code
-            + health_check_code
+            + check_helper_section
+            + readiness_section
+            + health_section
             + main_code
         )
 
@@ -1352,6 +1565,24 @@ def build_project(
     generator = CodeGenerator(project_path, settings, output_dir, build_env=build_env, copy_env=copy_env)
     generator.generate()
 
+    # Copy startup.py to output directory if it exists (after server generation)
+    startup_path = project_path / "startup.py"
+    if startup_path.exists():
+        dest_path = output_dir / "startup.py"
+        shutil.copy2(startup_path, dest_path)
+        console.print(get_status_text("success", "Startup script copied to build directory"))
+
+    # Copy optional check files to build directory
+    readiness_path = project_path / "readiness.py"
+    if readiness_path.exists():
+        shutil.copy2(readiness_path, output_dir)
+        console.print(get_status_text("success", "Readiness script copied to build directory"))
+
+    health_path = project_path / "health.py"
+    if health_path.exists():
+        shutil.copy2(health_path, output_dir)
+        console.print(get_status_text("success", "Health script copied to build directory"))
+
     # Platform registration (only for prod builds)
     if build_env == "prod":
         console.print()

golf/core/config.py

@@ -83,9 +83,9 @@ class Settings(BaseSettings):
     )
 
     # Health check configuration
-    health_check_enabled: bool = Field(False, description="Enable health check endpoint")
+    health_check_enabled: bool = Field(False, description="Enable health check endpoint (deprecated - use health.py)")
     health_check_path: str = Field("/health", description="Health check endpoint path")
-    health_check_response: str = Field("OK", description="Health check response text")
+    health_check_response: str = Field("OK", description="Health check response text (deprecated - use health.py)")
 
     # HTTP session behaviour
     stateless_http: bool = Field(

{golf_mcp-0.2.9.dist-info → golf_mcp-0.2.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: golf-mcp
-Version: 0.2.9
+Version: 0.2.11
 Summary: Framework for building MCP servers
 Author-email: Antoni Gmitruk <antoni@golf.dev>
 License-Expression: Apache-2.0

{golf_mcp-0.2.9.dist-info → golf_mcp-0.2.11.dist-info}/RECORD

@@ -1,4 +1,4 @@
-golf/__init__.py,sha256=CB9wu2mcYCSJopA-uO1-_87ebOSTDcXJ8uOktQ4va20,306
+golf/__init__.py,sha256=OpQ-bTTwRbO4KTjcnQgvU8ccnCWbcM-xPCnqQkEJNz0,307
 golf/_endpoints.py,sha256=-mvAmjx3YtqfAdajO13Kv7LKVBMdqsKqX0_3aCmCK4I,317
 golf/_endpoints.py.in,sha256=MeqcSF6xinnPknpBGF26xA9FYmSYKSWqCFXOSDlXiOA,216
 golf/_endpoints_fallback.py,sha256=CD6m45Ams1A9HVKowY8dCFUDMiFmJ8ZWSwHCENvU5u4,386
@@ -16,11 +16,11 @@ golf/commands/build.py,sha256=sLq9lSW4naq2vIlBreKI5SGnviQrhBWw13zfOZOKhuM,2293
 golf/commands/init.py,sha256=KkAg_3-KxBDFOcZqUHqcPAkDipykFVaLWpQ2tydnVPk,9617
 golf/commands/run.py,sha256=a8GSwLt6E2cUJespv-u3jbD-rNUMHqF3VArD1uXV-Vk,4299
 golf/core/__init__.py,sha256=4bKeskJ2fPaZqkz2xQScSa3phRLLrmrczwSL632jv-o,52
-golf/core/builder.py,sha256=Tx6AtWnnasY_Rfu1CEdhE7y3hZdN0RuhwLevJU9vZgo,66355
+golf/core/builder.py,sha256=c0Phx77jkEJnks-FGN7ONuBmC5tQsVIHbwJxQkDAjKE,78180
 golf/core/builder_auth.py,sha256=SXPCpc5ipntoNqIAIA2ZCeGmEua6QVs7yC3MDtGKAro,8224
 golf/core/builder_metrics.py,sha256=j6Gtgd867o46JbDfSNGNsHt1QtV1XHKUJs1z8r4siQM,8830
 golf/core/builder_telemetry.py,sha256=86bp7UlMUN6JyQRrZ5EizovP6AJ_q65OANJTeJXDIKc,3421
-golf/core/config.py,sha256=h8LWKdD-5vS8vRGs1qsCI2d8EbtjIKuXM3rUJ0T7EZ8,7452
+golf/core/config.py,sha256=BD4bfyzIv1TZYDmBQTuzSXNF6aHfzWXY65LemAxdjNo,7510
 golf/core/parser.py,sha256=f9WqmLWlFuXQCObl2Qmna9bp_Bo0p0eIlukzwFaBSzo,43373
 golf/core/platform.py,sha256=0TxLfVPBhBR82aJAQWEJcnkGuQv65C9gYYy7P2foUVk,6662
 golf/core/telemetry.py,sha256=dXoWrgrQpj_HGrl_8TBZmRnuLxFKEn0GSDWQ9qq3ZQM,15686
@@ -48,9 +48,9 @@ golf/utilities/__init__.py,sha256=X9iY9yi3agz1GVcn8-qWeOCt8CSSsruHxqPNtiF63TY,53
 golf/utilities/context.py,sha256=DGGvhVe---QMhy0wtdWhNp-_WVk1NvAcOFn0uBKBpYo,1579
 golf/utilities/elicitation.py,sha256=MParZZZsY45s70-KXduHa6IvpWXnLW2FCPfrGijMaHs,5223
 golf/utilities/sampling.py,sha256=88nDv-trBE4gZQbcnMjXl3LW6TiIhv5zR_cuEIGjaIM,7233
-golf_mcp-0.2.9.dist-info/licenses/LICENSE,sha256=5_j2f6fTJmvfmUewzElhkpAaXg2grVoxKouOA8ihV6E,11348
-golf_mcp-0.2.9.dist-info/METADATA,sha256=67-svZP_no-mw7BBDGwoQJJ_RCcqCQH5uEAk7jfqUF0,9370
-golf_mcp-0.2.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-golf_mcp-0.2.9.dist-info/entry_points.txt,sha256=5y7rHYM8jGpU-nfwdknCm5XsApLulqsnA37MO6BUTYg,43
-golf_mcp-0.2.9.dist-info/top_level.txt,sha256=BQToHcBUufdyhp9ONGMIvPE40jMEtmI20lYaKb4hxOg,5
-golf_mcp-0.2.9.dist-info/RECORD,,
+golf_mcp-0.2.11.dist-info/licenses/LICENSE,sha256=5_j2f6fTJmvfmUewzElhkpAaXg2grVoxKouOA8ihV6E,11348
+golf_mcp-0.2.11.dist-info/METADATA,sha256=DDudTuflPauNfgHynFhldQLFI7MlJ-leZBZBhAdZpuY,9371
+golf_mcp-0.2.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+golf_mcp-0.2.11.dist-info/entry_points.txt,sha256=5y7rHYM8jGpU-nfwdknCm5XsApLulqsnA37MO6BUTYg,43
+golf_mcp-0.2.11.dist-info/top_level.txt,sha256=BQToHcBUufdyhp9ONGMIvPE40jMEtmI20lYaKb4hxOg,5
+golf_mcp-0.2.11.dist-info/RECORD,,