cp_desktop/

sync.rs

use cp_core::{CPError, CognitiveDiff, Hlc, Result};
use cp_sync::{CryptoEngine, DeviceIdentity, EncryptedPayload, PairedDevice};
use std::sync::Mutex;
use tracing::{info, warn};
use uuid::Uuid;

const KEYRING_SERVICE: &str = "canon-protocol";
const KEYRING_USER: &str = "node-identity-seed";

/// Manages node identity and tracks local changes for network sync.
///
/// Records document/chunk/embedding mutations as `CognitiveDiffs`.
/// The identity seed is stored in the platform keychain (macOS Keychain,
/// Linux secret-service) with a plaintext file fallback for environments
/// where no keychain is available.
pub struct SyncManager {
    identity: DeviceIdentity,
    pending_diff: Mutex<CognitiveDiff>,
    paired_devices: Mutex<Vec<PairedDevice>>,
    /// Last known state root, used as `prev_root` for the next diff.
    last_state_root: Mutex<[u8; 32]>,
}

impl SyncManager {
    /// Create a new sync manager with a persistent node identity.
    ///
    /// Tries to load the identity seed from the file path first, then falls
    /// back to the platform keychain. On first run, generates a new identity
    /// and stores it in both locations. The file is always written as a backup
    /// even when keychain succeeds, ensuring reliable persistence.
    pub fn new(key_path: &std::path::Path) -> Result<Self> {
        let identity = if key_path.exists() {
            let seed = load_seed_from_file(key_path)?;
            if let Err(e) = store_seed_in_keychain(&seed) {
                warn!("Could not sync seed to keychain: {}", e);
            }
            info!("Loaded node identity from {}", key_path.display());
            DeviceIdentity::from_seed(seed)
        } else if let Ok(Some(seed)) = load_seed_from_keychain() {
            info!("Loaded node identity from platform keychain");
            store_seed_in_file(key_path, &seed)?;
            DeviceIdentity::from_seed(seed)
        } else {
            let identity = DeviceIdentity::generate();
            let seed = identity.export_seed();
            store_seed_in_file(key_path, &seed)?;
            if let Err(e) = store_seed_in_keychain(&seed) {
                warn!("Could not store seed in keychain: {}", e);
            } else {
                info!("Stored node identity in platform keychain");
            }
            identity
        };

        Ok(Self::from_identity(identity))
    }

    /// Create a sync manager using file-based storage only.
    ///
    /// Skips all keychain access. Useful for headless environments (CI,
    /// containers, tests) where no platform keychain is available.
    pub fn new_file_only(key_path: &std::path::Path) -> Result<Self> {
        let identity = if key_path.exists() {
            let seed = load_seed_from_file(key_path)?;
            info!("Loaded node identity from {}", key_path.display());
            DeviceIdentity::from_seed(seed)
        } else {
            let identity = DeviceIdentity::generate();
            let seed = identity.export_seed();
            store_seed_in_file(key_path, &seed)?;
            identity
        };

        Ok(Self::from_identity(identity))
    }

    fn from_identity(identity: DeviceIdentity) -> Self {
        let device_id = Uuid::from_bytes(identity.device_id);
        let node_id = *device_id.as_bytes();
        let hlc = Hlc::new(
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_millis() as u64,
            node_id,
        );
        let pending = CognitiveDiff::empty([0u8; 32], device_id, 0, hlc);

        Self {
            identity,
            pending_diff: Mutex::new(pending),
            paired_devices: Mutex::new(Vec::new()),
            last_state_root: Mutex::new([0u8; 32]),
        }
    }

    /// Record a document addition (deduplicates by ID)
    pub fn record_add_doc(&self, doc: cp_core::Document) {
        let mut diff = self
            .pending_diff
            .lock()
            .expect("pending_diff lock poisoned");
        diff.added_docs.retain(|d| d.id != doc.id);
        diff.added_docs.push(doc);
    }

    /// Record a chunk addition (deduplicates by ID)
    pub fn record_add_chunk(&self, chunk: cp_core::Chunk) {
        let mut diff = self
            .pending_diff
            .lock()
            .expect("pending_diff lock poisoned");
        diff.added_chunks.retain(|c| c.id != chunk.id);
        diff.added_chunks.push(chunk);
    }

    /// Record an embedding addition (deduplicates by ID)
    pub fn record_add_embedding(&self, emb: cp_core::Embedding) {
        let mut diff = self
            .pending_diff
            .lock()
            .expect("pending_diff lock poisoned");
        diff.added_embeddings.retain(|e| e.id != emb.id);
        diff.added_embeddings.push(emb);
    }

    /// Record a document removal (deduplicates by ID)
    pub fn record_remove_doc(&self, doc_id: Uuid, chunk_ids: Vec<Uuid>, embedding_ids: Vec<Uuid>) {
        let mut diff = self
            .pending_diff
            .lock()
            .expect("pending_diff lock poisoned");
        if !diff.removed_doc_ids.contains(&doc_id) {
            diff.removed_doc_ids.push(doc_id);
        }
        for cid in chunk_ids {
            if !diff.removed_chunk_ids.contains(&cid) {
                diff.removed_chunk_ids.push(cid);
            }
        }
        for eid in embedding_ids {
            if !diff.removed_embedding_ids.contains(&eid) {
                diff.removed_embedding_ids.push(eid);
            }
        }
    }

    /// Take the pending diff and reset it. Used by the network layer to
    /// retrieve accumulated changes for gossip.
    pub fn take_pending_diff(&self) -> CognitiveDiff {
        let mut pending = self
            .pending_diff
            .lock()
            .expect("pending_diff lock poisoned");
        let old = pending.clone();
        let device_id = old.metadata.device_id;
        let node_id = *device_id.as_bytes();
        let hlc = Hlc::new(
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_millis() as u64,
            node_id,
        );
        let prev_root = *self
            .last_state_root
            .lock()
            .expect("state_root lock poisoned");
        *pending = CognitiveDiff::empty(prev_root, device_id, old.metadata.seq + 1, hlc);
        old
    }

    /// Update the last known state root. Call this after computing the
    /// Merkle root from the graph store so that the next diff's `prev_root`
    /// reflects the current state.
    pub fn update_state_root(&self, root: [u8; 32]) {
        *self
            .last_state_root
            .lock()
            .expect("state_root lock poisoned") = root;
    }

    /// Check whether there are pending changes to sync.
    pub fn has_pending_changes(&self) -> bool {
        let diff = self
            .pending_diff
            .lock()
            .expect("pending_diff lock poisoned");
        !diff.is_empty()
    }

    /// Get device identity for network operations
    pub fn get_identity(&self) -> &DeviceIdentity {
        &self.identity
    }

    /// Get device ID as hex string
    pub fn get_device_id_hex(&self) -> String {
        hex::encode(self.identity.device_id)
    }

    /// Get the X25519 public key for key agreement with remote nodes.
    pub fn x25519_public_key(&self) -> [u8; 32] {
        self.identity.x25519_public_key()
    }

    /// Pair with a remote device using X25519 key agreement.
    ///
    /// Performs Diffie-Hellman key exchange to derive a shared encryption
    /// key, then stores the paired device for future encrypted diff exchange.
    pub fn pair_with_remote(
        &self,
        remote_public_key: &[u8; 32],
        remote_x25519_public: &[u8; 32],
    ) -> Result<()> {
        let paired = self
            .identity
            .pair_with(remote_public_key, remote_x25519_public)?;
        info!("Paired with remote device {}", paired.device_id_hex());

        let mut devices = self
            .paired_devices
            .lock()
            .expect("paired_devices lock poisoned");
        // Replace existing pairing for same device
        devices.retain(|d| d.device_id != paired.device_id);
        devices.push(paired);
        Ok(())
    }

    /// Encrypt a diff for a specific paired device using their shared key.
    pub fn encrypt_diff_for_peer(
        &self,
        diff: &CognitiveDiff,
        peer_device_id: &[u8; 16],
    ) -> Result<Option<EncryptedPayload>> {
        let devices = self
            .paired_devices
            .lock()
            .expect("paired_devices lock poisoned");
        let Some(paired) = devices.iter().find(|d| &d.device_id == peer_device_id) else {
            return Ok(None);
        };

        let engine = CryptoEngine::from_keys(paired.encryption_key, self.identity.export_seed());
        let encrypted = engine.encrypt_diff(diff)?;
        Ok(Some(encrypted))
    }

    /// Get the list of paired device IDs.
    pub fn paired_device_ids(&self) -> Vec<[u8; 16]> {
        self.paired_devices
            .lock()
            .expect("paired_devices lock poisoned")
            .iter()
            .map(|d| d.device_id)
            .collect()
    }
}

// ============================================================================
// Platform keychain storage
// ============================================================================

#[cfg(any(target_os = "macos", target_os = "linux"))]
fn load_seed_from_keychain() -> std::result::Result<Option<[u8; 32]>, String> {
    let entry = keyring::Entry::new(KEYRING_SERVICE, KEYRING_USER)
        .map_err(|e| format!("Failed to create keyring entry: {e}"))?;
    match entry.get_secret() {
        Ok(secret) => {
            if secret.len() != 32 {
                return Err(format!("Invalid seed length in keychain: {}", secret.len()));
            }
            let mut seed = [0u8; 32];
            seed.copy_from_slice(&secret);
            Ok(Some(seed))
        }
        Err(keyring::Error::NoEntry) => Ok(None),
        Err(e) => Err(format!("Keychain read error: {e}")),
    }
}

#[cfg(any(target_os = "macos", target_os = "linux"))]
fn store_seed_in_keychain(seed: &[u8; 32]) -> std::result::Result<(), String> {
    let entry = keyring::Entry::new(KEYRING_SERVICE, KEYRING_USER)
        .map_err(|e| format!("Failed to create keyring entry: {e}"))?;
    entry
        .set_secret(seed)
        .map_err(|e| format!("Keychain write error: {e}"))
}

#[cfg(not(any(target_os = "macos", target_os = "linux")))]
fn load_seed_from_keychain() -> std::result::Result<Option<[u8; 32]>, String> {
    Err("Platform keychain not available".to_string())
}

#[cfg(not(any(target_os = "macos", target_os = "linux")))]
fn store_seed_in_keychain(_seed: &[u8; 32]) -> std::result::Result<(), String> {
    Err("Platform keychain not available".to_string())
}

// ============================================================================
// File-based fallback storage
// ============================================================================

fn load_seed_from_file(path: &std::path::Path) -> Result<[u8; 32]> {
    let data = std::fs::read(path).map_err(CPError::Io)?;
    if data.len() != 32 {
        return Err(CPError::Crypto("Invalid key file length".into()));
    }
    let mut seed = [0u8; 32];
    seed.copy_from_slice(&data);
    Ok(seed)
}

fn store_seed_in_file(path: &std::path::Path, seed: &[u8; 32]) -> Result<()> {
    std::fs::write(path, seed).map_err(CPError::Io)?;
    #[cfg(unix)]
    {
        use std::os::unix::fs::PermissionsExt;
        let perms = std::fs::Permissions::from_mode(0o600);
        std::fs::set_permissions(path, perms).map_err(CPError::Io)?;
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;
    use tempfile::TempDir;

    #[test]
    fn test_sync_manager_new_generates_identity() {
        let tmp = TempDir::new().unwrap();
        let key_path = tmp.path().join("test_key");
        let mgr = SyncManager::new_file_only(&key_path).unwrap();
        assert!(!mgr.get_device_id_hex().is_empty());
    }

    #[test]
    fn test_sync_manager_persists_identity() {
        let tmp = TempDir::new().unwrap();
        let key_path = tmp.path().join("test_key");

        let id1 = {
            let mgr = SyncManager::new_file_only(&key_path).unwrap();
            mgr.get_device_id_hex()
        };

        let id2 = {
            let mgr = SyncManager::new_file_only(&key_path).unwrap();
            mgr.get_device_id_hex()
        };

        assert_eq!(id1, id2, "Identity should persist across restarts");
    }

    #[test]
    fn test_record_and_take_diff() {
        let tmp = TempDir::new().unwrap();
        let key_path = tmp.path().join("test_key");
        let mgr = SyncManager::new_file_only(&key_path).unwrap();

        assert!(!mgr.has_pending_changes());

        let doc = cp_core::Document::new(std::path::PathBuf::from("test.md"), b"content", 12345);
        mgr.record_add_doc(doc);
        assert!(mgr.has_pending_changes());

        let diff = mgr.take_pending_diff();
        assert_eq!(diff.added_docs.len(), 1);
        assert!(!mgr.has_pending_changes());
    }

    #[test]
    fn test_file_fallback_permissions() {
        let tmp = TempDir::new().unwrap();
        let key_path = tmp.path().join("test_key");
        let seed = [42u8; 32];
        store_seed_in_file(&key_path, &seed).unwrap();

        #[cfg(unix)]
        {
            use std::os::unix::fs::PermissionsExt;
            let meta = std::fs::metadata(&key_path).unwrap();
            let mode = meta.permissions().mode() & 0o777;
            assert_eq!(mode, 0o600, "Key file should have 0600 permissions");
        }

        let loaded = load_seed_from_file(&key_path).unwrap();
        assert_eq!(loaded, seed);
    }
}