client.rs

//! Client management commands
//!
//! IPC commands for managing AI clients (Cursor, VS Code, etc.).

use mcpmux_core::{Client, ConnectionMode};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::sync::Arc;
use tauri::State;
use tokio::sync::RwLock;
use uuid::Uuid;

use crate::commands::gateway::GatewayAppState;
use crate::state::AppState;

/// Response for client listing
#[derive(Debug, Serialize)]
pub struct ClientResponse {
    pub id: String,
    pub name: String,
    pub client_type: String,
    pub connection_mode: String,
    pub locked_space_id: Option<String>,
    pub grants: HashMap<String, Vec<String>>,
    pub last_seen: Option<String>,
}

impl From<Client> for ClientResponse {
    fn from(c: Client) -> Self {
        let (mode, locked_id) = match &c.connection_mode {
            ConnectionMode::Locked { space_id } => {
                ("locked".to_string(), Some(space_id.to_string()))
            }
            ConnectionMode::FollowActive => ("follow_active".to_string(), None),
            ConnectionMode::AskOnChange { .. } => ("ask_on_change".to_string(), None),
        };

        let grants: HashMap<String, Vec<String>> = c
            .grants
            .iter()
            .map(|(k, v)| (k.to_string(), v.iter().map(|u| u.to_string()).collect()))
            .collect();

        Self {
            id: c.id.to_string(),
            name: c.name,
            client_type: c.client_type,
            connection_mode: mode,
            locked_space_id: locked_id,
            grants,
            last_seen: c.last_seen.map(|dt| dt.to_rfc3339()),
        }
    }
}

/// Input for creating a client
#[derive(Debug, Deserialize)]
pub struct CreateClientInput {
    pub name: String,
    pub client_type: String,
    pub connection_mode: String,
    pub locked_space_id: Option<String>,
}

/// Input for updating client grants
#[derive(Debug, Deserialize)]
pub struct UpdateGrantsInput {
    pub space_id: String,
    pub feature_set_ids: Vec<String>,
}

/// List all clients.
#[tauri::command]
pub async fn list_clients(state: State<'_, AppState>) -> Result<Vec<ClientResponse>, String> {
    let clients = state
        .client_repository
        .list()
        .await
        .map_err(|e| e.to_string())?;

    Ok(clients.into_iter().map(Into::into).collect())
}

/// Get a client by ID.
#[tauri::command]
pub async fn get_client(
    id: String,
    state: State<'_, AppState>,
) -> Result<Option<ClientResponse>, String> {
    let uuid = Uuid::parse_str(&id).map_err(|e| e.to_string())?;
    let client = state
        .client_repository
        .get(&uuid)
        .await
        .map_err(|e| e.to_string())?;

    Ok(client.map(Into::into))
}

/// Create a new client.
#[tauri::command]
pub async fn create_client(
    input: CreateClientInput,
    state: State<'_, AppState>,
) -> Result<ClientResponse, String> {
    let connection_mode = match input.connection_mode.as_str() {
        "locked" => {
            let space_id = input
                .locked_space_id
                .ok_or("locked_space_id required for locked mode")?;
            let uuid = Uuid::parse_str(&space_id).map_err(|e| e.to_string())?;
            ConnectionMode::Locked { space_id: uuid }
        }
        "ask_on_change" => ConnectionMode::AskOnChange { triggers: vec![] },
        _ => ConnectionMode::FollowActive,
    };

    let mut client = Client::new(&input.name, &input.client_type);
    client.connection_mode = connection_mode;

    state
        .client_repository
        .create(&client)
        .await
        .map_err(|e| e.to_string())?;

    Ok(client.into())
}

/// Delete a client.
#[tauri::command]
pub async fn delete_client(id: String, state: State<'_, AppState>) -> Result<(), String> {
    let uuid = Uuid::parse_str(&id).map_err(|e| e.to_string())?;
    state
        .client_repository
        .delete(&uuid)
        .await
        .map_err(|e| e.to_string())
}

/// Update client grants for a specific space (using client_grants table).
#[tauri::command]
pub async fn update_client_grants(
    client_id: String,
    input: UpdateGrantsInput,
    state: State<'_, AppState>,
) -> Result<ClientResponse, String> {
    let client_uuid = Uuid::parse_str(&client_id).map_err(|e| e.to_string())?;

    // Verify client exists
    let client = state
        .client_repository
        .get(&client_uuid)
        .await
        .map_err(|e| e.to_string())?
        .ok_or("Client not found")?;

    // Update grants using the client_grants table
    state
        .client_repository
        .set_grants_for_space(&client_uuid, &input.space_id, &input.feature_set_ids)
        .await
        .map_err(|e| e.to_string())?;

    Ok(client.into())
}

/// Get effective grants for a specific client and space.
/// This includes explicit grants PLUS the default feature set (merged as a set).
#[tauri::command]
pub async fn get_client_grants(
    client_id: String,
    space_id: String,
    state: State<'_, AppState>,
) -> Result<Vec<String>, String> {
    let client_uuid = Uuid::parse_str(&client_id).map_err(|e| e.to_string())?;

    // Get effective grants (explicit + default, deduplicated)
    state
        .client_service
        .get_effective_grants(&client_uuid, &space_id)
        .await
        .map_err(|e| e.to_string())
}

/// Get all grants for a client across all spaces.
#[tauri::command]
pub async fn get_all_client_grants(
    client_id: String,
    state: State<'_, AppState>,
) -> Result<HashMap<String, Vec<String>>, String> {
    let client_uuid = Uuid::parse_str(&client_id).map_err(|e| e.to_string())?;

    state
        .client_repository
        .get_all_grants(&client_uuid)
        .await
        .map_err(|e| e.to_string())
}

/// Grant a specific feature set to a client.
///
/// Emits MCP list_changed notifications to connected clients.
#[tauri::command]
pub async fn grant_feature_set_to_client(
    client_id: String,
    space_id: String,
    feature_set_id: String,
    state: State<'_, AppState>,
    gateway_state: State<'_, Arc<RwLock<GatewayAppState>>>,
) -> Result<(), String> {
    let client_uuid = Uuid::parse_str(&client_id).map_err(|e| e.to_string())?;
    let space_uuid = Uuid::parse_str(&space_id).map_err(|e| e.to_string())?;

    // Grant the feature set
    state
        .client_repository
        .grant_feature_set(&client_uuid, &space_id, &feature_set_id)
        .await
        .map_err(|e| e.to_string())?;

    // Emit notifications if gateway is running
    let gw_state = gateway_state.read().await;
    if let Some(ref emitter) = gw_state.event_emitter {
        emitter.emit_all_changed_for_space(space_uuid);
    }

    Ok(())
}

/// Revoke a specific feature set from a client.
///
/// Emits MCP list_changed notifications to connected clients.
#[tauri::command]
pub async fn revoke_feature_set_from_client(
    client_id: String,
    space_id: String,
    feature_set_id: String,
    state: State<'_, AppState>,
    gateway_state: State<'_, Arc<RwLock<GatewayAppState>>>,
) -> Result<(), String> {
    let client_uuid = Uuid::parse_str(&client_id).map_err(|e| e.to_string())?;
    let space_uuid = Uuid::parse_str(&space_id).map_err(|e| e.to_string())?;

    // Revoke the feature set
    state
        .client_repository
        .revoke_feature_set(&client_uuid, &space_id, &feature_set_id)
        .await
        .map_err(|e| e.to_string())?;

    // Emit notifications if gateway is running
    let gw_state = gateway_state.read().await;
    if let Some(ref emitter) = gw_state.event_emitter {
        emitter.emit_all_changed_for_space(space_uuid);
    }

    Ok(())
}

/// Update client connection mode.
///
/// Emits MCP list_changed notifications when the client's effective space changes.
#[tauri::command]
pub async fn update_client_mode(
    client_id: String,
    mode: String,
    locked_space_id: Option<String>,
    state: State<'_, AppState>,
    gateway_state: State<'_, Arc<RwLock<GatewayAppState>>>,
) -> Result<ClientResponse, String> {
    let client_uuid = Uuid::parse_str(&client_id).map_err(|e| e.to_string())?;

    let mut client = state
        .client_repository
        .get(&client_uuid)
        .await
        .map_err(|e| e.to_string())?
        .ok_or("Client not found")?;

    client.connection_mode = match mode.as_str() {
        "locked" => {
            let space_id = locked_space_id.ok_or("locked_space_id required for locked mode")?;
            let uuid = Uuid::parse_str(&space_id).map_err(|e| e.to_string())?;
            ConnectionMode::Locked { space_id: uuid }
        }
        "ask_on_change" => ConnectionMode::AskOnChange { triggers: vec![] },
        _ => ConnectionMode::FollowActive,
    };
    client.updated_at = chrono::Utc::now();

    state
        .client_repository
        .update(&client)
        .await
        .map_err(|e| e.to_string())?;

    // Emit notifications for the space this client is now using
    let gw_state = gateway_state.read().await;
    if let Some(emitter) = &gw_state.event_emitter {
        match &client.connection_mode {
            ConnectionMode::Locked { space_id } => {
                emitter.emit_all_changed_for_space(*space_id);
            }
            _ => {
                // For follow_active or ask_on_change, notifications will be sent
                // when the client reconnects and resolves its space
            }
        }
    }

    Ok(client.into())
}

/// Create preset clients (Cursor, VS Code, Claude Desktop).
#[tauri::command]
pub async fn init_preset_clients(state: State<'_, AppState>) -> Result<(), String> {
    let existing = state
        .client_repository
        .list()
        .await
        .map_err(|e| e.to_string())?;

    // Create Cursor if not exists
    if !existing.iter().any(|c| c.client_type == "cursor") {
        let cursor = Client::cursor();
        state
            .client_repository
            .create(&cursor)
            .await
            .map_err(|e| e.to_string())?;
    }

    // Create VS Code if not exists
    if !existing.iter().any(|c| c.client_type == "vscode") {
        let vscode = Client::vscode();
        state
            .client_repository
            .create(&vscode)
            .await
            .map_err(|e| e.to_string())?;
    }

    // Create Claude Desktop if not exists
    if !existing.iter().any(|c| c.client_type == "claude") {
        let claude = Client::claude_desktop();
        state
            .client_repository
            .create(&claude)
            .await
            .map_err(|e| e.to_string())?;
    }

    Ok(())
}