fix(server): clean sandbox-owned records on reconcile delete

Author: johntmyers

crates/openshell-server/src/compute/mod.rs

@@ -480,36 +480,7 @@ impl ComputeRuntime {
             .map_err(|e| Status::internal(format!("persist sandbox failed: {e}")))?;
         self.sandbox_index.update_from_sandbox(&sandbox);
         self.sandbox_watch_bus.notify(&id);
-
-        if let Ok(records) = self.store.list(SshSession::object_type(), 1000, 0).await {
-            for record in records {
-                if let Ok(session) = SshSession::decode(record.payload.as_slice())
-                    && session.sandbox_id == id
-                    && let Err(e) = self
-                        .store
-                        .delete(SshSession::object_type(), session.object_id())
-                        .await
-                {
-                    warn!(
-                        session_id = %session.object_id(),
-                        error = %e,
-                        "Failed to delete SSH session during sandbox cleanup"
-                    );
-                }
-            }
-        }
-
-        if let Err(e) = self
-            .store
-            .delete_by_name(SANDBOX_SETTINGS_OBJECT_TYPE, sandbox.object_name())
-            .await
-        {
-            warn!(
-                sandbox_id = %id,
-                error = %e,
-                "Failed to delete sandbox settings during cleanup"
-            );
-        }
+        self.cleanup_sandbox_owned_records(&sandbox).await;
 
         let driver_sandbox = driver_sandbox_from_public(&sandbox);
         let deleted = self
@@ -959,6 +930,15 @@ impl ComputeRuntime {
     }
 
     async fn apply_deleted_locked(&self, sandbox_id: &str) -> Result<(), String> {
+        let sandbox = self
+            .store
+            .get_message::<Sandbox>(sandbox_id)
+            .await
+            .map_err(|e| e.to_string())?;
+        if let Some(sandbox) = sandbox.as_ref() {
+            self.cleanup_sandbox_owned_records(sandbox).await;
+        }
+
         let _ = self
             .store
             .delete(Sandbox::object_type(), sandbox_id)
@@ -970,6 +950,44 @@ impl ComputeRuntime {
         Ok(())
     }
 
+    async fn cleanup_sandbox_owned_records(&self, sandbox: &Sandbox) {
+        self.cleanup_sandbox_ssh_sessions(sandbox.object_id()).await;
+
+        if let Err(e) = self
+            .store
+            .delete_by_name(SANDBOX_SETTINGS_OBJECT_TYPE, sandbox.object_name())
+            .await
+        {
+            warn!(
+                sandbox_id = %sandbox.object_id(),
+                sandbox_name = %sandbox.object_name(),
+                error = %e,
+                "Failed to delete sandbox settings during cleanup"
+            );
+        }
+    }
+
+    async fn cleanup_sandbox_ssh_sessions(&self, sandbox_id: &str) {
+        if let Ok(records) = self.store.list(SshSession::object_type(), 1000, 0).await {
+            for record in records {
+                if let Ok(session) = SshSession::decode(record.payload.as_slice())
+                    && session.sandbox_id == sandbox_id
+                    && let Err(e) = self
+                        .store
+                        .delete(SshSession::object_type(), session.object_id())
+                        .await
+                {
+                    warn!(
+                        sandbox_id = %sandbox_id,
+                        session_id = %session.object_id(),
+                        error = %e,
+                        "Failed to delete SSH session during sandbox cleanup"
+                    );
+                }
+            }
+        }
+    }
+
     fn cleanup_sandbox_state(&self, sandbox_id: &str) {
         self.tracing_log_bus.remove(sandbox_id);
         self.tracing_log_bus.platform_event_bus.remove(sandbox_id);
@@ -1776,6 +1794,21 @@ mod tests {
         }
     }
 
+    fn ssh_session_record(id: &str, sandbox_id: &str) -> SshSession {
+        SshSession {
+            metadata: Some(openshell_core::proto::datamodel::v1::ObjectMeta {
+                id: id.to_string(),
+                name: format!("session-{id}"),
+                created_at_ms: 1000000,
+                labels: std::collections::HashMap::new(),
+            }),
+            sandbox_id: sandbox_id.to_string(),
+            token: format!("token-{id}"),
+            revoked: false,
+            expires_at_ms: 0,
+        }
+    }
+
     fn make_driver_condition(reason: &str, message: &str) -> DriverCondition {
         DriverCondition {
             r#type: "Ready".to_string(),
@@ -2427,6 +2460,19 @@ mod tests {
         let sandbox = sandbox_record("sb-1", "sandbox-a", SandboxPhase::Provisioning);
         runtime.store.put_message(&sandbox).await.unwrap();
         runtime.sandbox_index.update_from_sandbox(&sandbox);
+        runtime
+            .store
+            .put(
+                SANDBOX_SETTINGS_OBJECT_TYPE,
+                "settings-sb-1",
+                sandbox.object_name(),
+                br#"{"revision":1,"settings":{}}"#,
+                None,
+            )
+            .await
+            .unwrap();
+        let session = ssh_session_record("session-1", sandbox.object_id());
+        runtime.store.put_message(&session).await.unwrap();
 
         let mut watch_rx = runtime.sandbox_watch_bus.subscribe(sandbox.object_id());
 
@@ -2449,6 +2495,22 @@ mod tests {
                 .sandbox_id_for_sandbox_name(sandbox.object_name())
                 .is_none()
         );
+        assert!(
+            runtime
+                .store
+                .get_by_name(SANDBOX_SETTINGS_OBJECT_TYPE, sandbox.object_name())
+                .await
+                .unwrap()
+                .is_none()
+        );
+        assert!(
+            runtime
+                .store
+                .get_message::<SshSession>(session.object_id())
+                .await
+                .unwrap()
+                .is_none()
+        );
         let _ = watch_rx.try_recv();
         assert!(matches!(
             watch_rx.try_recv(),