request sync + over WS + merge devices + fix deployment scripts

wakey-control-plane/src/api/control.rs

@@ -5,7 +5,7 @@ mod stats;
 
 pub use devices::{
     attach_device_identifier, attach_observation_identifier, create_known_device,
-    forget_known_device, list_known_devices,
+    forget_known_device, list_known_devices, merge_known_device,
 };
 pub use enroll::{
     EnrollTokenStatus, IssueEnrollTokenResponse, RevokeAgentResponse, RevokeEnrollTokenResponse,
@@ -13,6 +13,7 @@ pub use enroll::{
     set_agent_nickname,
 };
 pub use observations::{
-    list_agent_observation_history, list_agent_observations, upload_agent_observations,
+    list_agent_observation_history, list_agent_observations, request_agent_observation_sync,
+    upload_agent_observations,
 };
 pub use stats::{StateStatsResponse, state_stats};

wakey-control-plane/src/api/control/devices.rs

@@ -56,6 +56,11 @@ pub struct ForgetKnownDeviceResponse {
     pub forgotten: bool,
 }
 
+#[derive(Debug, Deserialize)]
+pub struct MergeKnownDeviceRequest {
+    pub source_device_id: String,
+}
+
 pub async fn create_known_device(
     State(state): State<AppState>,
     Json(req): Json<CreateKnownDeviceRequest>,
@@ -193,6 +198,33 @@ pub async fn attach_observation_identifier(
     }
 }
 
+pub async fn merge_known_device(
+    State(state): State<AppState>,
+    AxumPath(device_id): AxumPath<String>,
+    Json(req): Json<MergeKnownDeviceRequest>,
+) -> Result<impl IntoResponse, (StatusCode, Json<serde_json::Value>)> {
+    match state
+        .store
+        .merge_known_devices(&device_id, &req.source_device_id)
+        .await
+    {
+        Ok(Some(device)) => Ok((StatusCode::OK, Json(known_device_response(device)))),
+        Ok(None) => Err(json_error(
+            StatusCode::NOT_FOUND,
+            "known_device_not_found",
+            "target or source known device not found",
+        )),
+        Err(err) => {
+            warn!(error = %err, "failed to merge known devices");
+            Err(json_error(
+                StatusCode::BAD_REQUEST,
+                "merge_known_device_failed",
+                &err.to_string(),
+            ))
+        }
+    }
+}
+
 fn known_device_response(device: crate::state::KnownDevice) -> KnownDeviceResponse {
     KnownDeviceResponse {
         device_id: device.device_id,

wakey-control-plane/src/api/control/observations.rs

@@ -1,12 +1,13 @@
 use axum::Json;
-use axum::extract::{Query, State};
+use axum::extract::{Path as AxumPath, Query, State};
 use axum::http::StatusCode;
 use axum::response::IntoResponse;
 use serde::Deserialize;
 use tracing::warn;
+use wakey_agent::protocol::ServerMessage;
 
 use crate::api::json_error;
-use crate::runtime::AppState;
+use crate::runtime::{AppState, SessionEvent};
 use crate::state::{
     AgentDeviceObservationEvent, AgentDeviceObservationInput, AgentDeviceObservationView,
 };
@@ -35,6 +36,12 @@ pub struct UploadAgentObservationsResponse {
     pub accepted: usize,
 }
 
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+pub struct RequestAgentObservationSyncResponse {
+    pub agent_id: String,
+    pub requested: bool,
+}
+
 #[derive(Debug, Deserialize)]
 pub struct ListObservationsQuery {
     pub agent_id: Option<String>,
@@ -130,6 +137,43 @@ pub async fn list_agent_observations(
     }
 }
 
+pub async fn request_agent_observation_sync(
+    State(state): State<AppState>,
+    AxumPath(agent_id): AxumPath<String>,
+) -> Result<impl IntoResponse, (StatusCode, Json<serde_json::Value>)> {
+    let tx = {
+        let sessions = state.sessions.read().await;
+        sessions.get(&agent_id).map(|session| session.tx.clone())
+    };
+    let Some(tx) = tx else {
+        return Ok((
+            StatusCode::NOT_FOUND,
+            Json(RequestAgentObservationSyncResponse {
+                agent_id,
+                requested: false,
+            }),
+        ));
+    };
+
+    match tx.send(SessionEvent::Message(ServerMessage::SyncObservations)) {
+        Ok(()) => Ok((
+            StatusCode::OK,
+            Json(RequestAgentObservationSyncResponse {
+                agent_id,
+                requested: true,
+            }),
+        )),
+        Err(err) => {
+            warn!(error = %err, "failed to request agent observation sync");
+            Err(json_error(
+                StatusCode::BAD_GATEWAY,
+                "agent_observation_sync_request_failed",
+                &err.to_string(),
+            ))
+        }
+    }
+}
+
 pub async fn list_agent_observation_history(
     State(state): State<AppState>,
     Query(query): Query<ListObservationHistoryQuery>,

wakey-control-plane/src/api/mod.rs

@@ -14,8 +14,8 @@ pub use control::{
     StateStatsResponse, attach_device_identifier, attach_observation_identifier,
     create_known_device, enroll, forget_known_device, healthz, issue_enroll_token,
     list_agent_observation_history, list_agent_observations, list_enroll_tokens,
-    list_known_devices, revoke_agent, revoke_enroll_token, set_agent_nickname, state_stats,
-    upload_agent_observations,
+    list_known_devices, merge_known_device, request_agent_observation_sync, revoke_agent,
+    revoke_enroll_token, set_agent_nickname, state_stats, upload_agent_observations,
 };
 
 pub fn json_error(