@appstrata/cli 0.1.0

package/python/appstrata_dev_player/server.py

@@ -0,0 +1,508 @@
+"""
+HTTP server for the AppStrata Python player.
+
+Exposes the same endpoints as the Node dev-http-player:
+  POST /api/send     — client sends messages to the player
+  GET  /api/receive  — player sends messages to the client (SSE or polling)
+  GET  /             — status page
+
+Port of: packages/cli/src/commands/dev-http-player.ts
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from typing import Any, Callable
+
+from aiohttp import web
+
+from appstrata_player.app_host import AppHost, CapabilityServices
+from appstrata_player.transport.http_sse import HttpSseHostTransport
+from appstrata_player.transport.http_polling import HttpPollingHostTransport
+from appstrata_player.transport.manager import HttpHostTransportManager
+from appstrata_player.services.storage import MockStorage
+from appstrata_player.services.proxy import MockProxy
+from appstrata_player.services.media_cache import MockMediaCache
+from appstrata_player.services.static_api import MockStatic
+
+logger = logging.getLogger(__name__)
+
+POLL_IDLE_TIMEOUT = 60  # seconds
+
+
+def resolve_capabilities(capabilities: list[str] | None) -> list[str]:
+    """Resolve capability config into a flat list of capability names."""
+    if not capabilities:
+        return ["storage", "proxy"]
+    if "all" in capabilities:
+        return ["storage", "proxy", "mediaCache", "static"]
+    return list(capabilities)
+
+
+def build_capability_services(capabilities: list[str]) -> CapabilityServices:
+    """Create mock service instances for the given capabilities."""
+    return CapabilityServices(
+        storage=MockStorage() if "storage" in capabilities else None,
+        proxy=MockProxy() if "proxy" in capabilities else None,
+        media_cache=MockMediaCache() if "mediaCache" in capabilities else None,
+        static=MockStatic() if "static" in capabilities else None,
+    )
+
+
+def build_app_context(
+    context_config: dict[str, Any], capabilities: list[str]
+) -> dict[str, Any]:
+    """Build an AppContext dict from dev config and capabilities."""
+    default_device = {
+        "id": "dev-player",
+        "name": "Development Player",
+        "type": "web-player",
+        "platformName": "AppStrata Dev",
+        "locale": "en-US",
+        "timezone": "UTC",
+    }
+
+    device_cfg = context_config.get("device", {})
+    device = {**default_device, **device_cfg}
+
+    return {
+        "instanceId": context_config.get("instanceId", "dev-instance"),
+        "duration": context_config.get("duration", 30),
+        "mode": context_config.get("mode", "development"),
+        "environment": context_config.get("environment", "development"),
+        "viewportWidth": context_config.get("viewportWidth", 1920),
+        "viewportHeight": context_config.get("viewportHeight", 1080),
+        "config": context_config.get("config", {}),
+        "resources": context_config.get("resources", []),
+        "device": device,
+        "hasCapability": lambda cap: cap in capabilities,
+    }
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# SERVER
+# ═══════════════════════════════════════════════════════════════════════════
+
+
+class DevHttpPlayerServer:
+    """
+    HTTP dev player server backed by aiohttp.
+
+    Manages sessions, transports, and the aiohttp web application.
+    """
+
+    def __init__(
+        self,
+        *,
+        port: int,
+        host: bool = False,
+        transport_mode: str = "sse",
+        config: dict[str, Any],
+    ) -> None:
+        self._port = port
+        self._bind_host = "0.0.0.0" if host else "127.0.0.1"
+        self._transport_mode = transport_mode
+        self._config = config
+        self._sessions: dict[str, AppHost] = {}
+
+        # Transport manager
+        factory: Callable[[str], Any]
+        if transport_mode == "sse":
+            factory = lambda sid: HttpSseHostTransport(sid)
+        else:
+            factory = lambda sid: HttpPollingHostTransport(sid)
+        self._manager = HttpHostTransportManager(factory)
+
+        # Shutdown event — SSE handlers wait on this to exit promptly
+        self._shutdown_event = asyncio.Event()
+
+        # SSE bookkeeping
+        self._sse_connections: list[dict[str, Any]] = []
+
+        # Polling idle timers
+        self._poll_idle_timers: dict[str, asyncio.TimerHandle] = {}
+
+        # Proxy sessions that need cleanup
+        self._proxies: list[MockProxy] = []
+
+        # Global message logger
+        self._manager.on_message(
+            lambda sid, msg: logger.info(
+                "[AppStrata Dev HTTP Player] [%s] <- %s", sid, msg.get("type")
+            )
+        )
+
+    # ── Config updates ────────────────────────────────────────────────
+
+    def update_config(self, new_config: dict[str, Any]) -> None:
+        """Handle a config update (hot reload from Node CLI)."""
+        self._config = new_config
+        capabilities = resolve_capabilities(new_config.get("capabilities"))
+        new_services = build_capability_services(capabilities)
+        new_context = build_app_context(
+            new_config.get("context", {}), capabilities
+        )
+        for session_id, app_host in self._sessions.items():
+            logger.info(
+                "[AppStrata Dev HTTP Player] [%s] Updating context", session_id
+            )
+            app_host.update_services(new_services)
+            app_host.update_context(new_context)
+
+    # ── Session management ────────────────────────────────────────────
+
+    def _ensure_session(self, session_id: str) -> None:
+        if session_id in self._sessions:
+            return
+
+        logger.info("[%s] New session", session_id)
+
+        transport = self._manager.get_transport(session_id)
+        capabilities = resolve_capabilities(self._config.get("capabilities"))
+        context = build_app_context(self._config.get("context", {}), capabilities)
+        services = build_capability_services(capabilities)
+
+        # Track proxy for cleanup
+        if services.proxy:
+            self._proxies.append(services.proxy)
+
+        lifecycle = self._config.get("lifecycle", {})
+        init_delay = lifecycle.get("initDelay", 0) / 1000.0
+        show_delay = lifecycle.get("showDelay", 50) / 1000.0
+        start_delay = lifecycle.get("startDelay", 50) / 1000.0
+        hide_delay = lifecycle.get("hideDelay", 100) / 1000.0
+        stop_delay = lifecycle.get("stopDelay", 50) / 1000.0
+
+        app_host = AppHost(
+            services=services,
+            transport=transport,
+            debug=True,
+            retry_interval=0.5,
+            mark_complete=lambda: self._on_mark_complete(
+                session_id, hide_delay, stop_delay
+            ),
+            log_fn=lambda level, message, data: logger.info(
+                "[AppStrata Dev HTTP Player] [%s] [%s] %s %s",
+                session_id,
+                level,
+                message,
+                data or "",
+            ),
+        )
+
+        loop = asyncio.get_event_loop()
+
+        def _fire_init() -> None:
+            logger.info(
+                "[AppStrata Dev HTTP Player] [%s] fireInit", session_id
+            )
+            app_host.fire_init(context)
+
+        def _fire_show() -> None:
+            logger.info(
+                "[AppStrata Dev HTTP Player] [%s] fireShow", session_id
+            )
+            app_host.fire_show()
+
+        def _fire_start() -> None:
+            logger.info(
+                "[AppStrata Dev HTTP Player] [%s] fireStart", session_id
+            )
+            app_host.fire_start()
+
+        loop.call_later(init_delay, _fire_init)
+        loop.call_later(init_delay + show_delay, _fire_show)
+        loop.call_later(init_delay + show_delay + start_delay, _fire_start)
+
+        self._sessions[session_id] = app_host
+
+    def _on_mark_complete(
+        self, session_id: str, hide_delay: float, stop_delay: float
+    ) -> None:
+        logger.info(
+            "[AppStrata Dev HTTP Player] [%s] App marked complete", session_id
+        )
+        app_host = self._sessions.get(session_id)
+        if not app_host:
+            return
+
+        loop = asyncio.get_event_loop()
+        loop.call_later(
+            hide_delay,
+            lambda: (
+                logger.info(
+                    "[AppStrata Dev HTTP Player] [%s] fireHide", session_id
+                ),
+                app_host.fire_hide(),
+            ),
+        )
+        loop.call_later(
+            hide_delay + stop_delay,
+            lambda: (
+                logger.info(
+                    "[AppStrata Dev HTTP Player] [%s] fireStop", session_id
+                ),
+                app_host.fire_stop(),
+            ),
+        )
+
+    def _destroy_session(self, session_id: str) -> None:
+        app_host = self._sessions.pop(session_id, None)
+        if app_host:
+            app_host.destroy()
+        self._manager.close_session(session_id)
+
+    # ── Polling idle timer ────────────────────────────────────────────
+
+    def _reset_poll_idle_timer(self, session_id: str) -> None:
+        existing = self._poll_idle_timers.pop(session_id, None)
+        if existing:
+            existing.cancel()
+
+        loop = asyncio.get_event_loop()
+        self._poll_idle_timers[session_id] = loop.call_later(
+            POLL_IDLE_TIMEOUT,
+            lambda: (
+                logger.info(
+                    "[AppStrata Dev HTTP Player] [%s] No poll received in %ds — destroying session",
+                    session_id,
+                    POLL_IDLE_TIMEOUT,
+                ),
+                self._poll_idle_timers.pop(session_id, None),
+                self._destroy_session(session_id),
+            ),
+        )
+
+    # ── HTTP routes ───────────────────────────────────────────────────
+
+    async def _handle_send(self, request: web.Request) -> web.Response:
+        """POST /api/send — client sends messages to the player."""
+        try:
+            body = await request.json()
+        except Exception:
+            return web.json_response(
+                {"ok": False, "error": "Invalid JSON"}, status=400
+            )
+
+        session_id = request.headers.get("X-Session-Id")
+        if not session_id:
+            return web.json_response(
+                {"ok": False, "error": "Missing X-Session-Id header"}, status=400
+            )
+
+        self._ensure_session(session_id)
+        self._manager.get_transport(session_id).handle_incoming_message(body)
+        return web.json_response({"ok": True})
+
+    async def _handle_receive(self, request: web.Request) -> web.StreamResponse:
+        """GET /api/receive — player sends messages to the client."""
+        session_id = request.query.get("sessionId")
+        if not session_id:
+            return web.Response(text="Missing sessionId", status=400)
+
+        self._ensure_session(session_id)
+
+        if self._transport_mode == "sse":
+            return await self._handle_receive_sse(request, session_id)
+        else:
+            return await self._handle_receive_polling(request, session_id)
+
+    async def _handle_receive_sse(
+        self, request: web.Request, session_id: str
+    ) -> web.StreamResponse:
+        logger.info(
+            "[AppStrata Dev HTTP Player] [%s] SSE connection opened", session_id
+        )
+
+        response = web.StreamResponse(
+            headers={
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "Access-Control-Allow-Origin": "*",
+                "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+                "Access-Control-Allow-Headers": "Content-Type, X-Session-Id",
+            }
+        )
+        await response.prepare(request)
+        await response.write(b": connected\n\n")
+
+        transport = self._manager.get_transport(session_id)
+        assert isinstance(transport, HttpSseHostTransport)
+
+        # Use a queue to serialize all writes to the response.
+        # The sse_writer (called synchronously by the transport) puts data
+        # into the queue; the loop below drains it and writes to the response.
+        # This avoids concurrent writes to the same StreamResponse.
+        write_queue: asyncio.Queue[str] = asyncio.Queue()
+
+        def sse_writer(data: str) -> None:
+            write_queue.put_nowait(data)
+
+        cleanup = transport.set_sse_writer(sse_writer)
+        conn_info = {"res": response, "cleanup": cleanup}
+        self._sse_connections.append(conn_info)
+
+        try:
+            shutdown_wait = asyncio.ensure_future(self._shutdown_event.wait())
+            while True:
+                get_data = asyncio.ensure_future(write_queue.get())
+                done, _ = await asyncio.wait(
+                    [get_data, shutdown_wait],
+                    timeout=15,
+                    return_when=asyncio.FIRST_COMPLETED,
+                )
+                if shutdown_wait in done:
+                    get_data.cancel()
+                    break
+                if get_data in done:
+                    await response.write(get_data.result().encode())
+                else:
+                    # Timeout — send heartbeat
+                    get_data.cancel()
+                    await response.write(b": heartbeat\n\n")
+        except (
+            ConnectionResetError,
+            ConnectionAbortedError,
+            ConnectionError,
+            OSError,
+            asyncio.CancelledError,
+        ):
+            pass
+        finally:
+            logger.info(
+                "[AppStrata Dev HTTP Player] [%s] SSE connection closed — destroying session",
+                session_id,
+            )
+            cleanup()
+            self._sse_connections = [
+                c for c in self._sse_connections if c["res"] is not response
+            ]
+            self._destroy_session(session_id)
+
+        return response
+
+    async def _handle_receive_polling(
+        self, request: web.Request, session_id: str
+    ) -> web.Response:
+        self._reset_poll_idle_timer(session_id)
+
+        transport = self._manager.get_transport(session_id)
+        assert isinstance(transport, HttpPollingHostTransport)
+
+        messages = await transport.handle_poll_request(30_000)
+        if messages is None:
+            return web.json_response(
+                {"error": "Poll already active for this session"}, status=409
+            )
+
+        return web.json_response({"messages": messages})
+
+    async def _handle_status(self, request: web.Request) -> web.Response:
+        """GET / — status page."""
+        sessions = list(self._sessions.keys())
+        session_html = (
+            "<p>No active sessions</p>"
+            if not sessions
+            else "".join(f'<div class="session">{s}</div>' for s in sessions)
+        )
+        html = f"""<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <title>AppStrata HTTP Dev Player (Python)</title>
+  <style>
+    body {{ font-family: system-ui, sans-serif; max-width: 800px; margin: 50px auto; padding: 20px; background: #f5f5f5; }}
+    h1 {{ color: #333; border-bottom: 2px solid #667eea; padding-bottom: 10px; }}
+    .info {{ background: white; padding: 20px; border-radius: 8px; margin: 20px 0; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }}
+    .session {{ background: #e8f5e9; padding: 10px; margin: 5px 0; border-radius: 4px; font-family: monospace; font-size: 14px; }}
+    .badge {{ display: inline-block; background: #667eea; color: white; padding: 2px 8px; border-radius: 4px; font-size: 12px; margin-left: 8px; }}
+  </style>
+</head>
+<body>
+  <h1>AppStrata HTTP Dev Player <span class="badge">Python</span></h1>
+  <div class="info">
+    <h3>Status: Running</h3>
+    <p>This server implements the AppStrata protocol over HTTP (Python runtime).</p>
+    <p>Transport mode: <strong>{self._transport_mode}</strong></p>
+    <div class="sessions">
+      <h3>Active Sessions:</h3>
+      {session_html}
+    </div>
+  </div>
+</body>
+</html>"""
+        return web.Response(text=html, content_type="text/html")
+
+    # ── CORS middleware ────────────────────────────────────────────────
+
+    @web.middleware
+    async def _cors_middleware(
+        self,
+        request: web.Request,
+        handler: Callable[..., Any],
+    ) -> web.StreamResponse:
+        if request.method == "OPTIONS":
+            response = web.Response(status=204)
+        else:
+            response = await handler(request)
+        response.headers["Access-Control-Allow-Origin"] = "*"
+        response.headers["Access-Control-Allow-Methods"] = "GET, POST, OPTIONS"
+        response.headers["Access-Control-Allow-Headers"] = "Content-Type, X-Session-Id"
+        return response
+
+    # ── Application setup ─────────────────────────────────────────────
+
+    def create_app(self) -> web.Application:
+        app = web.Application(middlewares=[self._cors_middleware])
+        app.router.add_post("/api/send", self._handle_send)
+        app.router.add_get("/api/receive", self._handle_receive)
+        app.router.add_get("/", self._handle_status)
+        return app
+
+    async def start(self) -> web.AppRunner:
+        """Start the server and return the runner (for clean shutdown)."""
+        app = self.create_app()
+        runner = web.AppRunner(app)
+        await runner.setup()
+        site = web.TCPSite(runner, self._bind_host, self._port)
+        await site.start()
+
+        logger.info("")
+        logger.info(
+            "[AppStrata Dev HTTP Player] HTTP Dev Player (Python) running on http://localhost:%d/",
+            self._port,
+        )
+        logger.info("  Transport mode: %s", self._transport_mode)
+        logger.info(
+            "  POST http://localhost:%d/api/send", self._port
+        )
+        logger.info(
+            "  GET  http://localhost:%d/api/receive", self._port
+        )
+        logger.info("")
+
+        return runner
+
+    async def shutdown(self) -> None:
+        """Clean shutdown."""
+        logger.info("[AppStrata Dev HTTP Player] Shutting down...")
+        # Signal all SSE handler loops to exit
+        self._shutdown_event.set()
+        # Give handlers a moment to exit cleanly
+        await asyncio.sleep(0.1)
+        # Close SSE connections
+        for conn in self._sse_connections:
+            conn["cleanup"]()
+        # Cancel poll timers
+        for timer in self._poll_idle_timers.values():
+            timer.cancel()
+        self._poll_idle_timers.clear()
+        # Close transports
+        self._manager.close_all()
+        # Close proxy sessions
+        for proxy in self._proxies:
+            await proxy.close()
+        logger.info("[AppStrata Dev HTTP Player] Server closed")