Method sync_sessions_to_storage

crates/opencode-server/src/server.rs:197–238

(&self)

    }

    pub async fn sync_sessions_to_storage(&self) -> anyhow::Result<()> {
        let (Some(session_repo), Some(message_repo)) = (&self.session_repo, &self.message_repo)
        else {
            return Ok(());
        };

        let snapshot: Vec<opencode_session::Session> = {
            let manager = self.sessions.lock().await;
            manager.list().into_iter().cloned().collect()
        };

        let snapshot_ids: HashSet<String> = snapshot.iter().map(|s| s.id.clone()).collect();
        let persisted = session_repo.list(None, 100_000).await?;

        for stale in persisted {
            if !snapshot_ids.contains(&stale.id) {
                message_repo.delete_for_session(&stale.id).await?;
                session_repo.delete(&stale.id).await?;
            }
        }

        for session in snapshot {
            let mut stored_session: opencode_types::Session =
                serde_json::from_value(serde_json::to_value(&session)?)?;
            let stored_messages: Vec<opencode_types::SessionMessage> =
                stored_session.messages.clone();
            stored_session.messages.clear();

            if session_repo.get(&stored_session.id).await?.is_some() {
                session_repo.update(&stored_session).await?;
            } else {
                session_repo.create(&stored_session).await?;
            }

            message_repo.delete_for_session(&stored_session.id).await?;
            for message in stored_messages {
                message_repo.create(&message).await?;
            }
        }

        Ok(())
    }
}

/// Convert opencode_config::ProviderConfig map to bootstrap ConfigProvider map.