feat(cloud): remove static credentials and add host console

apps/device-host-agent/host_agent/app.py

@@ -4,18 +4,25 @@ import asyncio
 from contextlib import suppress
 from dataclasses import dataclass
 
+import uvicorn
+
 from cloud.internal_api.models import AssignmentModel
 from device.manager import DeviceManager
-from driver.registry import build_driver_factory
 from host_agent.assignment import AssignmentExecutor
 from host_agent.client import HostAgentClient, HostAgentEnrollmentClient
 from host_agent.config import HostAgentConfig, load_host_agent_config
+from host_agent.devices import register_local_device
 from host_agent.enrollment import resolve_host_identity
 from host_agent.execution import create_execution_factories
 from host_agent.heartbeat import HeartbeatSynchronizer
+from host_agent.history import ConsoleHistoryStore
 from host_agent.identity import HostIdentityStore
 from host_agent.lease import ActiveAssignmentRunner
+from host_agent.local_account import LocalAccountStore
 from host_agent.processor import AssignmentProcessingResult, AssignmentProcessor
+from host_agent.status import AgentStatusTracker
+from host_agent.web.app import create_console_app
+from host_agent.web.auth import SessionManager
 from storage.device_config import DeviceConfigStore
 
 
@@ -24,6 +31,8 @@ class HostAgentApplication:
     client: HostAgentClient
     heartbeat: HeartbeatSynchronizer
     processor: AssignmentProcessor
+    console_server: uvicorn.Server | None = None
+    console_enrollment_client: HostAgentEnrollmentClient | None = None
 
     def run(self) -> None:
         asyncio.run(self.run_async())
@@ -32,6 +41,11 @@ class HostAgentApplication:
         stop_requested = stop or asyncio.Event()
         heartbeat_stop = asyncio.Event()
         heartbeat_task = asyncio.create_task(self.heartbeat.run(heartbeat_stop))
+        console_task = (
+            asyncio.create_task(self.console_server.serve())
+            if self.console_server is not None
+            else None
+        )
         active_processing: asyncio.Task[AssignmentProcessingResult] | None = None
         try:
             while not stop_requested.is_set():
@@ -60,11 +74,18 @@ class HostAgentApplication:
                 with suppress(Exception):
                     await asyncio.shield(active_processing)
             heartbeat_stop.set()
+            if self.console_server is not None:
+                self.console_server.should_exit = True
             try:
                 await asyncio.gather(heartbeat_task, return_exceptions=True)
                 with suppress(Exception):
                     await self.heartbeat.sync_once()
+                if console_task is not None:
+                    with suppress(asyncio.CancelledError):
+                        await asyncio.gather(console_task, return_exceptions=True)
             finally:
+                if self.console_enrollment_client is not None:
+                    self.console_enrollment_client.close()
                 await self.client.aclose()
 
     async def _claim_until_stopped(
@@ -104,13 +125,15 @@ def create_application(
 ) -> HostAgentApplication:
     startup_config = config or load_host_agent_config()
     config_store = device_config_store or DeviceConfigStore()
+    resolved_identity_store = identity_store or HostIdentityStore(
+        startup_config.identity_path
+    )
     owned_enrollment_client = enrollment_client is None
     bootstrap_client = enrollment_client or HostAgentEnrollmentClient(startup_config)
     try:
         resolved_config = resolve_host_identity(
             startup_config,
-            identity_store=identity_store
-            or HostIdentityStore(startup_config.identity_path),
+            identity_store=resolved_identity_store,
             client=bootstrap_client,
         )
         bootstrap_client.config = resolved_config
@@ -123,13 +146,93 @@ def create_application(
         if owned_enrollment_client:
             bootstrap_client.close()
     client = HostAgentClient(resolved_config)
-    heartbeat = HeartbeatSynchronizer(resolved_manager, client, resolved_config)
+
+    history_store: ConsoleHistoryStore | None = None
+    status_tracker: AgentStatusTracker | None = None
+    console_server: uvicorn.Server | None = None
+    console_enrollment_client: HostAgentEnrollmentClient | None = None
+    if resolved_config.console_enabled:
+        history_store = ConsoleHistoryStore(
+            resolved_config.identity_path.parent / "host_console_history.sqlite3",
+            limit=resolved_config.console_history_limit,
+        )
+        status_tracker = AgentStatusTracker()
+        if resolved_config.enrollment_managed:
+            console_enrollment_client = HostAgentEnrollmentClient(resolved_config)
+        console_app = create_console_app(
+            config=resolved_config,
+            manager=resolved_manager,
+            config_store=config_store,
+            local_account_store=LocalAccountStore(resolved_config.local_account_path),
+            identity_store=resolved_identity_store,
+            history_store=history_store,
+            status_tracker=status_tracker,
+            session_manager=SessionManager(
+                ttl_seconds=resolved_config.console_session_ttl_seconds
+            ),
+            enrollment_client=console_enrollment_client,
+        )
+        console_server = uvicorn.Server(
+            uvicorn.Config(
+                console_app,
+                host=resolved_config.console_bind_host,
+                port=resolved_config.console_port,
+                log_level="warning",
+            )
+        )
+
+    heartbeat = HeartbeatSynchronizer(
+        resolved_manager,
+        client,
+        resolved_config,
+        status_tracker=status_tracker,
+        on_sync=(
+            (
+                lambda device_count: history_store.record_heartbeat(
+                    device_count=device_count
+                )
+            )
+            if history_store is not None
+            else None
+        ),
+    )
     executor = AssignmentExecutor(create_execution_factories(resolved_manager))
     active_runner = ActiveAssignmentRunner(client, executor)
+    processor = AssignmentProcessor(
+        client,
+        active_runner,
+        status_tracker=status_tracker,
+        on_result=(
+            (
+                lambda assignment, result: _record_assignment_history(
+                    history_store, assignment, result
+                )
+            )
+            if history_store is not None
+            else None
+        ),
+    )
     return HostAgentApplication(
         client=client,
         heartbeat=heartbeat,
-        processor=AssignmentProcessor(client, active_runner),
+        processor=processor,
+        console_server=console_server,
+        console_enrollment_client=console_enrollment_client,
+    )
+
+
+def _record_assignment_history(
+    history_store: ConsoleHistoryStore,
+    assignment: AssignmentModel,
+    result: AssignmentProcessingResult,
+) -> None:
+    status = "done" if result.execution.status == "done" else "failed"
+    history_store.record_assignment(
+        task_id=assignment.task_id,
+        attempt=assignment.attempt,
+        status=status,
+        failure_reason=result.execution.failure_reason if status == "failed" else None,
+        device_id=assignment.device_id,
     )
 
 
@@ -141,24 +244,14 @@ def _configured_device_manager(
 ) -> DeviceManager:
     manager = DeviceManager()
     for device in config_store.list():
-        runtime_device_id = device["device_id"]
-        if config.enrollment_managed:
-            enrollment = enrollment_client.enroll_device(
-                local_device_id=device["device_id"],
-                driver_type=device["driver_type"],
-                name=device["name"],
-                capability_tags=[],
-            )
-            runtime_device_id = enrollment.device_id
-            config_store.set_cloud_device_id(device["device_id"], runtime_device_id)
-        manager.register_device(
-            runtime_device_id,
-            build_driver_factory(
-                device["driver_type"],
-                device["connection_info"],
-            ),
-            name=device["name"],
+        register_local_device(
+            config_store,
+            manager,
+            device_id=device["device_id"],
             driver_type=device["driver_type"],
             connection_info=device["connection_info"],
+            name=device["name"],
+            config=config,
+            enrollment_client=enrollment_client,
         )
     return manager