op-mcp 0.1.0

//! Item management tools for 1Password

use rust_mcp_schema::schema_utils::CallToolError;
use rust_mcp_schema::CallToolResult;
use rust_mcp_sdk::macros::{mcp_tool, JsonSchema};
use serde::{Deserialize, Serialize};

use crate::op::OpClient;
use crate::tools::enums::{ItemCategory, ShareExpiry};
use crate::tools::{json_result, op_error_to_tool_error, text_result};

// ============================================================================
// item_list Tool
// ============================================================================

/// List items in one or all vaults.
#[mcp_tool(
    name = "item_list",
    description = "List items in 1Password. Can filter by vault, categories, tags, or favorite status. Returns item summaries without sensitive field values."
)]
#[derive(Debug, Deserialize, Serialize, JsonSchema)]
pub struct ItemListTool {
    /// Optional vault name or ID to filter items. If not specified, lists items from all vaults.
    #[serde(default)]
    pub vault: Option<String>,

    /// Optional list of categories to filter by.
    #[serde(default)]
    pub categories: Option<Vec<ItemCategory>>,

    /// Optional list of tags to filter by.
    #[serde(default)]
    pub tags: Option<Vec<String>>,

    /// If true, only return items marked as favorites.
    #[serde(default)]
    pub favorite: Option<bool>,
}

impl ItemListTool {
    pub async fn call(&self, client: &OpClient) -> Result<CallToolResult, CallToolError> {
        let categories_strs: Option<Vec<String>> = self
            .categories
            .as_ref()
            .map(|c| c.iter().map(|cat| cat.to_string()).collect());
        let categories_refs: Option<Vec<&str>> = categories_strs
            .as_ref()
            .map(|c| c.iter().map(|s| s.as_str()).collect());
        let tags_refs: Option<Vec<&str>> = self
            .tags
            .as_ref()
            .map(|t| t.iter().map(|s| s.as_str()).collect());

        let result = client
            .item_list(
                self.vault.as_deref(),
                categories_refs.as_deref(),
                tags_refs.as_deref(),
                self.favorite,
            )
            .await
            .map_err(op_error_to_tool_error)?;
        json_result(&result)
    }
}

// ============================================================================
// item_get Tool
// ============================================================================

/// Get full details for a specific item.
#[mcp_tool(
    name = "item_get",
    description = "Get detailed information about a specific item by name or ID. By default, sensitive fields like passwords are hidden. Set reveal=true to show all field values."
)]
#[derive(Debug, Deserialize, Serialize, JsonSchema)]
pub struct ItemGetTool {
    /// The name or ID of the item to retrieve.
    pub item: String,

    /// Optional vault name or ID. Required if multiple items have the same name.
    #[serde(default)]
    pub vault: Option<String>,

    /// If true, reveal sensitive field values (passwords, keys, etc.). Default is false for security.
    #[serde(default)]
    pub reveal: bool,
}

impl ItemGetTool {
    pub async fn call(&self, client: &OpClient) -> Result<CallToolResult, CallToolError> {
        let result = client
            .item_get(&self.item, self.vault.as_deref(), self.reveal)
            .await
            .map_err(op_error_to_tool_error)?;
        json_result(&result)
    }
}

// ============================================================================
// item_create Tool
// ============================================================================

/// Create a new item in a vault.
#[mcp_tool(
    name = "item_create",
    description = "Create a new item in 1Password. Specify a category, title, vault, and fields. Fields are specified as 'field=value' or 'section.field=value' pairs."
)]
#[derive(Debug, Deserialize, Serialize, JsonSchema)]
pub struct ItemCreateTool {
    /// The category of item to create.
    pub category: ItemCategory,

    /// The title for the new item.
    pub title: String,

    /// The vault name or ID to create the item in.
    #[serde(default)]
    pub vault: Option<String>,

    /// Generate a password for the item. Can be a recipe like 'letters,digits,symbols,32' or just 'true' for defaults.
    #[serde(default)]
    pub generate_password: Option<String>,

    /// URL associated with the item (for LOGIN items).
    #[serde(default)]
    pub url: Option<String>,

    /// Tags to apply to the item.
    #[serde(default)]
    pub tags: Option<Vec<String>>,

    /// Field assignments in 'field=value' or 'section.field[type]=value' format.
    #[serde(default)]
    pub fields: Option<Vec<String>>,

    /// Mark the item as a favorite.
    #[serde(default)]
    pub favorite: bool,
}

impl ItemCreateTool {
    pub async fn call(&self, client: &OpClient) -> Result<CallToolResult, CallToolError> {
        let category_str = self.category.to_string();
        let tags_refs: Option<Vec<&str>> = self
            .tags
            .as_ref()
            .map(|t| t.iter().map(|s| s.as_str()).collect());
        let fields_refs: Option<Vec<&str>> = self
            .fields
            .as_ref()
            .map(|f| f.iter().map(|s| s.as_str()).collect());

        let result = client
            .item_create(
                &category_str,
                &self.title,
                self.vault.as_deref(),
                self.generate_password.as_deref(),
                self.url.as_deref(),
                tags_refs.as_deref(),
                fields_refs.as_deref(),
                self.favorite,
            )
            .await
            .map_err(op_error_to_tool_error)?;
        json_result(&result)
    }
}

// ============================================================================
// item_edit Tool
// ============================================================================

/// Edit an existing item.
#[mcp_tool(
    name = "item_edit",
    description = "Edit an existing item's fields, title, tags, or other properties. Fields are specified as 'field=value' or 'section.field=value' pairs."
)]
#[derive(Debug, Deserialize, Serialize, JsonSchema)]
pub struct ItemEditTool {
    /// The name or ID of the item to edit.
    pub item: String,

    /// Optional vault name or ID.
    #[serde(default)]
    pub vault: Option<String>,

    /// New title for the item.
    #[serde(default)]
    pub title: Option<String>,

    /// URL to update.
    #[serde(default)]
    pub url: Option<String>,

    /// Generate a new password. Can be a recipe like 'letters,digits,symbols,32'.
    #[serde(default)]
    pub generate_password: Option<String>,

    /// Tags to set on the item (replaces existing tags).
    #[serde(default)]
    pub tags: Option<Vec<String>>,

    /// Field assignments in 'field=value' or 'section.field[type]=value' format.
    #[serde(default)]
    pub fields: Option<Vec<String>>,

    /// Set favorite status.
    #[serde(default)]
    pub favorite: Option<bool>,
}

impl ItemEditTool {
    pub async fn call(&self, client: &OpClient) -> Result<CallToolResult, CallToolError> {
        let tags_refs: Option<Vec<&str>> = self
            .tags
            .as_ref()
            .map(|t| t.iter().map(|s| s.as_str()).collect());
        let fields_refs: Option<Vec<&str>> = self
            .fields
            .as_ref()
            .map(|f| f.iter().map(|s| s.as_str()).collect());

        let result = client
            .item_edit(
                &self.item,
                self.vault.as_deref(),
                self.title.as_deref(),
                self.url.as_deref(),
                self.generate_password.as_deref(),
                tags_refs.as_deref(),
                fields_refs.as_deref(),
                self.favorite,
            )
            .await
            .map_err(op_error_to_tool_error)?;
        json_result(&result)
    }
}

// ============================================================================
// item_delete Tool
// ============================================================================

/// Delete an item.
#[mcp_tool(
    name = "item_delete",
    description = "Delete or archive an item. By default, items are archived (moved to trash) and can be recovered. Use archive=false to permanently delete."
)]
#[derive(Debug, Deserialize, Serialize, JsonSchema)]
pub struct ItemDeleteTool {
    /// The name or ID of the item to delete.
    pub item: String,

    /// Optional vault name or ID.
    #[serde(default)]
    pub vault: Option<String>,

    /// If true (default), archive the item instead of permanently deleting.
    #[serde(default = "default_true")]
    pub archive: bool,
}

fn default_true() -> bool {
    true
}

impl ItemDeleteTool {
    pub async fn call(&self, client: &OpClient) -> Result<CallToolResult, CallToolError> {
        let result = client
            .item_delete(&self.item, self.vault.as_deref(), self.archive)
            .await
            .map_err(op_error_to_tool_error)?;
        text_result(result)
    }
}

// ============================================================================
// item_move Tool
// ============================================================================

/// Move an item to a different vault.
#[mcp_tool(
    name = "item_move",
    description = "Move an item from one vault to another. Requires appropriate permissions in both vaults."
)]
#[derive(Debug, Deserialize, Serialize, JsonSchema)]
pub struct ItemMoveTool {
    /// The name or ID of the item to move.
    pub item: String,

    /// The current vault name or ID (source).
    #[serde(default)]
    pub current_vault: Option<String>,

    /// The destination vault name or ID.
    pub destination_vault: String,
}

impl ItemMoveTool {
    pub async fn call(&self, client: &OpClient) -> Result<CallToolResult, CallToolError> {
        let result = client
            .item_move(&self.item, self.current_vault.as_deref(), &self.destination_vault)
            .await
            .map_err(op_error_to_tool_error)?;
        text_result(result)
    }
}

// ============================================================================
// item_share Tool
// ============================================================================

/// Create a shareable link for an item.
#[mcp_tool(
    name = "item_share",
    description = "Create a secure, time-limited link to share an item with someone. The link expires after the specified duration and can be limited to specific email addresses."
)]
#[derive(Debug, Deserialize, Serialize, JsonSchema)]
pub struct ItemShareTool {
    /// The name or ID of the item to share.
    pub item: String,

    /// Optional vault name or ID.
    #[serde(default)]
    pub vault: Option<String>,

    /// Link expiration duration. Default is 7 days.
    #[serde(default)]
    pub expiry: Option<ShareExpiry>,

    /// Limit access to these email addresses (comma-separated or array).
    #[serde(default)]
    pub emails: Option<Vec<String>>,

    /// If true, require the recipient to view the item only once.
    #[serde(default)]
    pub view_once: bool,
}

impl ItemShareTool {
    pub async fn call(&self, client: &OpClient) -> Result<CallToolResult, CallToolError> {
        let expiry_str = self.expiry.as_ref().map(|e| e.to_string());
        let emails_refs: Option<Vec<&str>> = self
            .emails
            .as_ref()
            .map(|e| e.iter().map(|s| s.as_str()).collect());

        let result = client
            .item_share(
                &self.item,
                self.vault.as_deref(),
                expiry_str.as_deref(),
                emails_refs.as_deref(),
                self.view_once,
            )
            .await
            .map_err(op_error_to_tool_error)?;
        text_result(result)
    }
}

// ============================================================================
// item_template_list Tool
// ============================================================================

/// List available item templates.
#[mcp_tool(
    name = "item_template_list",
    description = "List all available item templates/categories that can be used when creating new items."
)]
#[derive(Debug, Deserialize, Serialize, JsonSchema)]
pub struct ItemTemplateListTool {}

impl ItemTemplateListTool {
    pub async fn call(&self, client: &OpClient) -> Result<CallToolResult, CallToolError> {
        let result = client
            .item_template_list()
            .await
            .map_err(op_error_to_tool_error)?;
        json_result(&result)
    }
}

// ============================================================================
// item_template_get Tool
// ============================================================================

/// Get details for a specific item template.
#[mcp_tool(
    name = "item_template_get",
    description = "Get the field structure and details for a specific item template/category. Useful for understanding what fields are available when creating items."
)]
#[derive(Debug, Deserialize, Serialize, JsonSchema)]
pub struct ItemTemplateGetTool {
    /// The template name (category) to retrieve (e.g., 'LOGIN', 'SECURE_NOTE', 'CREDIT_CARD').
    pub template: String,
}

impl ItemTemplateGetTool {
    pub async fn call(&self, client: &OpClient) -> Result<CallToolResult, CallToolError> {
        let result = client
            .item_template_get(&self.template)
            .await
            .map_err(op_error_to_tool_error)?;
        json_result(&result)
    }
}