fix: rebrand MCP server Late -> Zernio, support ZERNIO_API_KEY env var

Critical bug fix: MCP server now reads ZERNIO_API_KEY (with LATE_API_KEY
fallback) instead of only LATE_API_KEY. Also reads ZERNIO_BASE_URL with
LATE_BASE_URL fallback.

Full rebrand across all MCP files:
- server.py: FastMCP name, instructions, docstring config example,
  env var priority (ZERNIO_API_KEY > LATE_API_KEY), error messages
- constants.py: SERVICE_NAME
- routes.py: error messages, health service name, auth instructions
- auth.py: docstrings
- config.py: docstrings
- http_server.py: startup messages, CLI description

Function names (set_late_api_key, extract_late_api_key, etc.) kept for
backwards compatibility with existing imports.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: mikipalet

src/late/mcp/auth.py

@@ -1,14 +1,16 @@
-"""Authentication module for Late MCP HTTP server."""
+"""Authentication module for Zernio MCP HTTP server."""
 
 import httpx
 from starlette.requests import Request
 
 
 def extract_late_api_key(request: Request) -> str | None:
     """
-    Extract Late API key from request Authorization header.
+    Extract Zernio API key from request Authorization header.
 
-    Expects: Authorization: Bearer <your_late_api_key>
+    Expects: Authorization: Bearer <your_api_key>
+
+    Function name kept as extract_late_api_key for backwards compatibility.
 
     Args:
         request: The incoming Starlette request.
@@ -24,10 +26,12 @@ def extract_late_api_key(request: Request) -> str | None:
 
 async def verify_late_api_key(api_key: str) -> bool:
     """
-    Verify Late API key by making a test request to Late API.
+    Verify Zernio API key by making a test request to Zernio API.
+
+    Function name kept as verify_late_api_key for backwards compatibility.
 
     Args:
-        api_key: The Late API key to verify.
+        api_key: The Zernio API key to verify.
 
     Returns:
         True if API key is valid, False otherwise.

src/late/mcp/config.py

@@ -1,4 +1,4 @@
-"""Configuration management for Late MCP HTTP server."""
+"""Configuration management for Zernio MCP HTTP server."""
 
 import os
 from dataclasses import dataclass
@@ -44,7 +44,7 @@ def validate_environment() -> None:
     Validate required environment variables are set.
 
     Note: No environment variables are required for the server.
-    Users provide their Late API keys via request headers.
+    Users provide their Zernio API keys via request headers.
     """
     # No validation needed - users provide API keys in headers
     pass

src/late/mcp/constants.py

@@ -1,7 +1,7 @@
-"""Constants for Late MCP HTTP server."""
+"""Constants for Zernio MCP HTTP server."""
 
 # Server information
-SERVICE_NAME = "Late MCP Server"
+SERVICE_NAME = "Zernio MCP Server"
 SERVICE_VERSION = "1.1.2"
 TRANSPORT_TYPE = "sse"
 

src/late/mcp/http_server.py

@@ -1,4 +1,4 @@
-"""HTTP/SSE server for Late MCP."""
+"""HTTP/SSE server for Zernio MCP."""
 
 import argparse
 import sys
@@ -45,7 +45,7 @@ def create_app(mcp_server, debug: bool = False) -> Starlette:
 
 def parse_args() -> argparse.Namespace:
     """Parse command-line arguments."""
-    parser = argparse.ArgumentParser(description="Late MCP HTTP/SSE Server")
+    parser = argparse.ArgumentParser(description="Zernio MCP HTTP/SSE Server")
     parser.add_argument("--host", help="Host to bind to (default: 0.0.0.0)")
     parser.add_argument("--port", type=int, help="Port to listen on (default: 8080)")
     parser.add_argument("--debug", action="store_true", help="Enable debug mode")
@@ -54,14 +54,14 @@ def parse_args() -> argparse.Namespace:
 
 def print_startup_info(config: ServerConfig) -> None:
     """Print server startup information."""
-    print("🚀 Late MCP HTTP Server starting...")
+    print("Zernio MCP HTTP Server starting...")
     print(f"   Host: {config.host}")
     print(f"   Port: {config.port}")
     print(f"   SSE endpoint: http://{config.host}:{config.port}{ENDPOINT_SSE}")
     print(f"   Health check: http://{config.host}:{config.port}{ENDPOINT_HEALTH}")
     print(f"   Debug mode: {'enabled' if config.debug else 'disabled'}")
     print()
-    print("📡 Ready to accept MCP connections!")
+    print("Ready to accept MCP connections!")
 
 
 def main() -> None:
@@ -81,7 +81,7 @@ def main() -> None:
 
         mcp_server = mcp._mcp_server
     except (ImportError, AttributeError) as e:
-        print(f"❌ Failed to access MCP server: {e}", file=sys.stderr)
+        print(f"Failed to access MCP server: {e}", file=sys.stderr)
         sys.exit(1)
 
     # Create app

src/late/mcp/routes.py

@@ -1,4 +1,4 @@
-"""Route handlers for Late MCP HTTP server."""
+"""Route handlers for Zernio MCP HTTP server."""
 
 import sys
 
@@ -31,7 +31,7 @@ async def handle_root(_request: Request) -> JSONResponse:
                 "health": f"{ENDPOINT_HEALTH} (GET) - Health check",
             },
             "documentation": DOCS_URL,
-            "authentication": "Required: 'Authorization: Bearer YOUR_LATE_API_KEY'",
+            "authentication": "Required: 'Authorization: Bearer YOUR_API_KEY'",
         }
     )
 
@@ -41,7 +41,7 @@ async def handle_health(_request: Request) -> JSONResponse:
     return JSONResponse(
         {
             "status": "healthy",
-            "service": "late-mcp-http",
+            "service": "zernio-mcp-http",
             "version": SERVICE_VERSION,
             "transport": TRANSPORT_TYPE,
         }
@@ -63,30 +63,30 @@ def create_sse_handler(mcp_server, sse_transport: SseServerTransport, debug: boo
 
     async def handle_sse(request: Request) -> Response:
         """Handle SSE connection with authentication."""
-        # Extract Late API key from request
-        late_api_key = extract_late_api_key(request)
-        if not late_api_key:
+        # Extract API key from request
+        api_key = extract_late_api_key(request)
+        if not api_key:
             return JSONResponse(
-                {"error": "Missing Late API key. Provide via Authorization header: 'Authorization: Bearer YOUR_API_KEY'"},
+                {"error": "Missing API key. Provide via Authorization header: 'Authorization: Bearer YOUR_API_KEY'"},
                 status_code=401
             )
 
-        # Verify Late API key by making test request
-        if not await verify_late_api_key(late_api_key):
+        # Verify API key by making test request
+        if not await verify_late_api_key(api_key):
             return JSONResponse(
-                {"error": "Invalid Late API key"},
+                {"error": "Invalid API key"},
                 status_code=401
             )
 
         # Store API key in request state for use in MCP tools
-        request.state.late_api_key = late_api_key
+        request.state.late_api_key = api_key
 
         # Establish SSE connection
         try:
             # Import here to set context variable before running MCP
             from late.mcp.server import set_late_api_key
 
-            set_late_api_key(late_api_key)
+            set_late_api_key(api_key)
 
             async with sse_transport.connect_sse(
                 request.scope,
@@ -100,7 +100,7 @@ async def handle_sse(request: Request) -> Response:
                 )
         except Exception as e:
             if debug:
-                print(f"❌ SSE connection error: {e}", file=sys.stderr)
+                print(f"SSE connection error: {e}", file=sys.stderr)
             return JSONResponse(
                 {"error": "SSE connection failed"}, status_code=500
             )

src/late/mcp/server.py

@@ -1,7 +1,7 @@
 """
-Late MCP Server.
+Zernio MCP Server.
 
-Exposes Late API functionality through Model Context Protocol.
+Exposes Zernio API functionality through Model Context Protocol.
 
 Usage:
     # Run directly
@@ -10,11 +10,11 @@
     # Or in Claude Desktop config:
     {
         "mcpServers": {
-            "late": {
+            "zernio": {
                 "command": "uvx",
-                "args": ["--from", "late-sdk[mcp]", "late-mcp"],
+                "args": ["--from", "zernio-sdk[mcp]", "zernio-mcp"],
                 "env": {
-                    "LATE_API_KEY": "your_api_key"
+                    "ZERNIO_API_KEY": "your_api_key"
                 }
             }
         }
@@ -36,8 +36,8 @@
 
 from .tool_definitions import use_tool_def
 
-# Context variable to store the Late API key for the current connection
-_late_api_key: ContextVar[str | None] = ContextVar("late_api_key", default=None)
+# Context variable to store the Zernio API key for the current connection
+_zernio_api_key: ContextVar[str | None] = ContextVar("zernio_api_key", default=None)
 
 # Cache for documentation content
 _docs_cache: dict[str, tuple[str, datetime]] = {}
@@ -46,36 +46,39 @@
 
 # Initialize MCP server
 mcp = FastMCP(
-    "Late",
+    "Zernio",
     instructions="""
-Late API server for scheduling social media posts.
+Zernio API server for scheduling social media posts.
 
 Available tools are prefixed by resource:
 - accounts_* : Manage connected social media accounts
 - profiles_* : Manage profiles (groups of accounts)
 - posts_*    : Create, list, update, delete posts
 - media_*    : Upload images and videos
-- docs_*     : Search Late API documentation
+- docs_*     : Search Zernio API documentation
 """,
 )
 
 
 def set_late_api_key(api_key: str) -> None:
     """
-    Set the Late API key for the current async context.
+    Set the Zernio API key for the current async context.
+
+    Kept as set_late_api_key for backwards compatibility with HTTP server routes.
 
     Args:
-        api_key: The Late API key to use for this connection.
+        api_key: The Zernio API key to use for this connection.
     """
-    _late_api_key.set(api_key)
+    _zernio_api_key.set(api_key)
 
 
 def _get_client() -> Late:
     """
-    Get Late client with API key from context or environment.
+    Get Zernio client with API key from context or environment.
 
     For HTTP/SSE connections, uses the API key from the current context.
-    For STDIO connections (Claude Desktop), falls back to LATE_API_KEY env var.
+    For STDIO connections (Claude Desktop), falls back to env vars.
+    Priority: ZERNIO_API_KEY > LATE_API_KEY (legacy).
 
     Returns:
         Late client instance.
@@ -84,20 +87,20 @@ def _get_client() -> Late:
         ValueError: If no API key is available.
     """
     # Try to get API key from context (HTTP/SSE mode)
-    api_key = _late_api_key.get()
+    api_key = _zernio_api_key.get()
 
-    # Fall back to environment variable (STDIO mode for Claude Desktop)
+    # Fall back to environment variables (STDIO mode for Claude Desktop)
     if not api_key:
-        api_key = os.getenv("LATE_API_KEY", "")
+        api_key = os.getenv("ZERNIO_API_KEY") or os.getenv("LATE_API_KEY", "")
 
     if not api_key:
         raise ValueError(
-            "Late API key is required. "
-            "For HTTP/SSE: provide via X-Late-API-Key header. "
-            "For STDIO: set LATE_API_KEY environment variable."
+            "Zernio API key is required. "
+            "For HTTP/SSE: provide via Authorization: Bearer header. "
+            "For STDIO: set ZERNIO_API_KEY environment variable."
         )
 
-    base_url = os.getenv("LATE_BASE_URL", None)
+    base_url = os.getenv("ZERNIO_BASE_URL") or os.getenv("LATE_BASE_URL", None)
     return Late(api_key=api_key, base_url=base_url)