mcp_sync/

target.rs

//! # Target Trait
//!
//! Defines the interface for sync targets (Antigravity, Claude, Codex, OpenCode).
//! This trait allows for polymorphic handling and easy addition of new targets.

use crate::canon::Canon;
use anyhow::Result;
use std::path::{Path, PathBuf};

/// Options passed to sync operations.
#[derive(Debug, Clone)]
pub struct SyncOptions {
    /// Remove servers not present in canonical config.
    pub clean: bool,
    /// Print changes but don't write files.
    pub dry_run: bool,
    /// Enable verbose output.
    pub verbose: bool,
}

impl SyncOptions {
    /// Creates new sync options.
    pub fn new(clean: bool, dry_run: bool, verbose: bool) -> Self {
        Self { clean, dry_run, verbose }
    }
}

/// Trait for MCP configuration sync targets.
///
/// Each target (e.g., Antigravity, Claude) implements this trait to provide
/// target-specific file paths and sync logic.
///
/// # Example
/// ```ignore
/// struct MyTarget;
/// 
/// impl Target for MyTarget {
///     fn name(&self) -> &'static str { "my-target" }
///     fn global_path(&self) -> Result<PathBuf> { Ok(home()?.join(".my-config.json")) }
///     fn project_path(&self, root: &Path) -> PathBuf { root.join(".my-config.json") }
///     fn sync(&self, path: &Path, canon: &Canon, opts: &SyncOptions) -> Result<()> {
///         // Implementation
///         Ok(())
///     }
/// }
/// ```
pub trait Target: Send + Sync {
    /// Returns the human-readable name of this target.
    fn name(&self) -> &'static str;

    /// Returns the path to the global (user-level) configuration file.
    fn global_path(&self) -> Result<PathBuf>;

    /// Returns the path to the project-level configuration file.
    fn project_path(&self, project_root: &Path) -> PathBuf;

    /// Syncs the canonical configuration to the target file.
    ///
    /// # Arguments
    /// * `path` - The target file path (global or project)
    /// * `canon` - The parsed canonical configuration
    /// * `opts` - Sync options (clean, dry_run, verbose)
    fn sync(&self, path: &Path, canon: &Canon, opts: &SyncOptions) -> Result<()>;

    /// Syncs to the global configuration file.
    fn sync_global(&self, canon: &Canon, opts: &SyncOptions) -> Result<()> {
        let path = self.global_path()?;
        self.sync(&path, canon, opts)
    }

    /// Syncs to the project configuration file.
    fn sync_project(&self, project_root: &Path, canon: &Canon, opts: &SyncOptions) -> Result<()> {
        let path = self.project_path(project_root);
        self.sync(&path, canon, opts)
    }
}

// ─────────────────────────── Target Manager ───────────────────────────

/// Manager for loading and managing sync targets.
///
/// Supports both built-in targets (Antigravity, Claude, Codex, OpenCode)
/// and dynamically loaded targets from shared libraries.
///
/// # Example
/// ```ignore
/// use mcp_sync::TargetManager;
///
/// let mut mgr = TargetManager::new();
///
/// // Load all built-in targets
/// mgr.load_builtin_all();
///
/// // Load a custom target from dylib
/// unsafe {
///     mgr.load_dynamic(Path::new("./my_target.dylib"))?;
/// }
///
/// // Sync all targets
/// for target in mgr.targets() {
///     target.sync_global(&canon, &opts)?;
/// }
/// ```
pub struct TargetManager {
    targets: Vec<Box<dyn Target>>,
    #[allow(dead_code)]
    libraries: Vec<libloading::Library>,
}

impl TargetManager {
    /// Creates a new empty target manager.
    pub fn new() -> Self {
        Self {
            targets: Vec::new(),
            libraries: Vec::new(),
        }
    }

    /// Creates a target manager pre-loaded with all built-in targets.
    pub fn with_builtins() -> Self {
        let mut mgr = Self::new();
        mgr.load_builtin_all();
        mgr
    }

    /// Loads all built-in targets.
    pub fn load_builtin_all(&mut self) {
        use crate::targets::{AntigravityTarget, ClaudeTarget, CodexTarget, OpenCodeTarget};
        
        self.targets.push(Box::new(AntigravityTarget));
        self.targets.push(Box::new(ClaudeTarget));
        self.targets.push(Box::new(CodexTarget));
        self.targets.push(Box::new(OpenCodeTarget));
    }

    /// Loads a specific built-in target by name.
    pub fn load_builtin(&mut self, name: &str) -> Result<()> {
        use crate::targets::{AntigravityTarget, ClaudeTarget, CodexTarget, OpenCodeTarget};
        use anyhow::bail;
        
        match name.to_lowercase().as_str() {
            "antigravity" => self.targets.push(Box::new(AntigravityTarget)),
            "claude" => self.targets.push(Box::new(ClaudeTarget)),
            "codex" => self.targets.push(Box::new(CodexTarget)),
            "opencode" => self.targets.push(Box::new(OpenCodeTarget)),
            _ => bail!("unknown built-in target: {}", name),
        }
        Ok(())
    }

    /// Loads a custom target from a dynamic library.
    ///
    /// The library must export a `create_target` function:
    /// ```ignore
    /// #[unsafe(no_mangle)]
    /// pub extern "C" fn create_target() -> *mut dyn Target {
    ///     Box::into_raw(Box::new(MyTarget::new()))
    /// }
    /// ```
    ///
    /// # Safety
    /// The caller must ensure the library is compatible and the
    /// `create_target` function returns a valid Target pointer.
    pub unsafe fn load_dynamic(&mut self, path: &Path) -> Result<()> {
        use anyhow::Context;
        
        let lib = unsafe {
            libloading::Library::new(path)
                .with_context(|| format!("failed to load library {:?}", path))?
        };
        
        let create_fn: libloading::Symbol<unsafe extern "C" fn() -> *mut dyn Target> = unsafe {
            lib.get(b"create_target")
                .with_context(|| "library missing create_target symbol")?
        };
        
        let raw_ptr = unsafe { create_fn() };
        let target = unsafe { Box::from_raw(raw_ptr) };
        
        self.targets.push(target);
        self.libraries.push(lib);
        
        Ok(())
    }

    /// Returns an iterator over all loaded targets.
    pub fn targets(&self) -> impl Iterator<Item = &dyn Target> {
        self.targets.iter().map(|b| b.as_ref())
    }

    /// Returns a mutable iterator over all loaded targets.
    pub fn targets_mut(&mut self) -> impl Iterator<Item = &mut Box<dyn Target>> {
        self.targets.iter_mut()
    }

    /// Returns the number of loaded targets.
    pub fn count(&self) -> usize {
        self.targets.len()
    }

    /// Returns true if no targets are loaded.
    pub fn is_empty(&self) -> bool {
        self.targets.is_empty()
    }

    /// Finds a target by name.
    pub fn find(&self, name: &str) -> Option<&dyn Target> {
        self.targets.iter()
            .map(|b| b.as_ref())
            .find(|t| t.name().eq_ignore_ascii_case(name))
    }

    /// Syncs all targets to their global configuration files.
    pub fn sync_all_global(&self, canon: &Canon, opts: &SyncOptions) -> Result<()> {
        for target in self.targets() {
            target.sync_global(canon, opts)?;
        }
        Ok(())
    }

    /// Syncs all targets to their project configuration files.
    pub fn sync_all_project(&self, project_root: &Path, canon: &Canon, opts: &SyncOptions) -> Result<()> {
        for target in self.targets() {
            target.sync_project(project_root, canon, opts)?;
        }
        Ok(())
    }
}

impl Default for TargetManager {
    fn default() -> Self {
        Self::new()
    }
}