chore(secrets-mcp): 0.5.1 — 移除 entry type 归一化，MCP 参数兼容字符串形式

- 去掉 taxonomy 对 entry type 的自动映射与 metadata.subtype 回填；仅 trim 后入库
- MCP tools：Vec/Map/bool 等可选字段支持 JSON 内嵌字符串解析，并改进解析失败提示
- 新增 deser 单元测试；README/AGENTS 与 models 注释同步

Made-with: Cursor

crates/secrets-core/src/models.rs

@@ -4,7 +4,7 @@ use serde_json::Value;
 use std::collections::BTreeMap;
 use uuid::Uuid;
 
-/// A top-level entry (server, service, key, person, …).
+/// A top-level entry (server, service, account, person, …).
 /// Sensitive fields are stored separately in `secrets`.
 #[derive(Debug, Serialize, Deserialize, sqlx::FromRow)]
 pub struct Entry {

crates/secrets-core/src/service/add.rs

@@ -9,7 +9,6 @@ use crate::crypto;
 use crate::db;
 use crate::error::{AppError, DbErrorContext};
 use crate::models::EntryRow;
-use crate::taxonomy;
 
 // ── Key/value parsing helpers ─────────────────────────────────────────────────
 
@@ -186,11 +185,10 @@ pub struct AddParams<'a> {
 }
 
 pub async fn run(pool: &PgPool, params: AddParams<'_>, master_key: &[u8; 32]) -> Result<AddResult> {
-    let Value::Object(mut metadata_map) = build_json(params.meta_entries)? else {
+    let Value::Object(metadata_map) = build_json(params.meta_entries)? else {
         unreachable!("build_json always returns a JSON object");
     };
-    let normalized_entry_type =
-        taxonomy::normalize_entry_type_and_metadata(params.entry_type, &mut metadata_map);
+    let entry_type = params.entry_type.trim();
     let metadata = Value::Object(metadata_map);
     let secret_json = build_json(params.secret_entries)?;
     let meta_keys = collect_key_paths(params.meta_entries)?;
@@ -232,7 +230,7 @@ pub async fn run(pool: &PgPool, params: AddParams<'_>, master_key: &[u8; 32]) ->
                 entry_id: ex.id,
                 user_id: params.user_id,
                 folder: params.folder,
-                entry_type: &normalized_entry_type,
+                entry_type,
                 name: params.name,
                 version: ex.version,
                 action: "add",
@@ -262,7 +260,7 @@ pub async fn run(pool: &PgPool, params: AddParams<'_>, master_key: &[u8; 32]) ->
         )
         .bind(uid)
         .bind(params.folder)
-        .bind(&normalized_entry_type)
+        .bind(entry_type)
         .bind(params.name)
         .bind(params.notes)
         .bind(params.tags)
@@ -285,7 +283,7 @@ pub async fn run(pool: &PgPool, params: AddParams<'_>, master_key: &[u8; 32]) ->
                RETURNING id"#,
         )
         .bind(params.folder)
-        .bind(&normalized_entry_type)
+        .bind(entry_type)
         .bind(params.name)
         .bind(params.notes)
         .bind(params.tags)
@@ -307,7 +305,7 @@ pub async fn run(pool: &PgPool, params: AddParams<'_>, master_key: &[u8; 32]) ->
                 entry_id,
                 user_id: params.user_id,
                 folder: params.folder,
-                entry_type: &normalized_entry_type,
+                entry_type,
                 name: params.name,
                 version: current_entry_version,
                 action: "create",
@@ -434,7 +432,7 @@ pub async fn run(pool: &PgPool, params: AddParams<'_>, master_key: &[u8; 32]) ->
         params.user_id,
         "add",
         params.folder,
-        &normalized_entry_type,
+        entry_type,
         params.name,
         serde_json::json!({
             "tags": params.tags,
@@ -449,7 +447,7 @@ pub async fn run(pool: &PgPool, params: AddParams<'_>, master_key: &[u8; 32]) ->
     Ok(AddResult {
         name: params.name.to_string(),
         folder: params.folder.to_string(),
-        entry_type: normalized_entry_type,
+        entry_type: entry_type.to_string(),
         tags: params.tags.to_vec(),
         meta_keys,
         secret_keys,

crates/secrets-core/src/service/update.rs

@@ -11,7 +11,6 @@ use crate::service::add::{
     collect_field_paths, collect_key_paths, flatten_json_fields, insert_path, parse_key_path,
     parse_kv, remove_path,
 };
-use crate::taxonomy;
 
 #[derive(Debug, serde::Serialize)]
 pub struct UpdateResult {
@@ -501,13 +500,7 @@ pub async fn update_fields_by_id(
         tracing::warn!(error = %e, "failed to snapshot entry history before web update");
     }
 
-    let mut metadata_map = match params.metadata {
-        Value::Object(m) => m.clone(),
-        _ => Map::new(),
-    };
-    let normalized_type =
-        taxonomy::normalize_entry_type_and_metadata(params.entry_type, &mut metadata_map);
-    let normalized_metadata = Value::Object(metadata_map);
+    let entry_type = params.entry_type.trim();
 
     let res = sqlx::query(
         "UPDATE entries SET folder = $1, type = $2, name = $3, notes = $4, tags = $5, metadata = $6, \
@@ -515,11 +508,11 @@ pub async fn update_fields_by_id(
          WHERE id = $7 AND version = $8",
     )
     .bind(params.folder)
-    .bind(&normalized_type)
+    .bind(entry_type)
     .bind(params.name)
     .bind(params.notes)
     .bind(params.tags)
-    .bind(&normalized_metadata)
+    .bind(params.metadata)
     .bind(row.id)
     .bind(row.version)
     .execute(&mut *tx)
@@ -546,7 +539,7 @@ pub async fn update_fields_by_id(
         Some(user_id),
         "update",
         params.folder,
-        &normalized_type,
+        entry_type,
         params.name,
         serde_json::json!({
             "source": "web",

crates/secrets-core/src/taxonomy.rs

@@ -1,111 +1,4 @@
-use serde_json::{Map, Value};
-
-fn normalize_token(input: &str) -> String {
-    input.trim().to_lowercase().replace('_', "-")
-}
-
-fn normalize_subtype_token(input: &str) -> String {
-    normalize_token(input)
-}
-
-fn map_legacy_entry_type(input: &str) -> Option<(&'static str, &'static str)> {
-    match input {
-        "log-ingestion-endpoint" => Some(("service", "log-ingestion")),
-        "cloud-api" => Some(("service", "cloud-api")),
-        "git-server" => Some(("service", "git")),
-        "mqtt-broker" => Some(("service", "mqtt-broker")),
-        "database" => Some(("service", "database")),
-        "monitoring-dashboard" => Some(("service", "monitoring")),
-        "dns-api" => Some(("service", "dns-api")),
-        "notification-webhook" => Some(("service", "webhook")),
-        "api-endpoint" => Some(("service", "api-endpoint")),
-        "credential" | "credential-key" => Some(("service", "credential")),
-        "key" => Some(("service", "credential")),
-        _ => None,
-    }
-}
-
-/// Normalize entry `type` and optionally backfill `metadata.subtype` for legacy values.
-///
-/// This keeps backward compatibility:
-/// - stable primary types stay unchanged
-/// - known legacy long-tail types are mapped to `service` + `metadata.subtype`
-/// - unknown values are kept (normalized to kebab-case) instead of hard failing
-pub fn normalize_entry_type_and_metadata(
-    entry_type: &str,
-    metadata: &mut Map<String, Value>,
-) -> String {
-    let original_raw = entry_type.trim();
-    let normalized = normalize_token(original_raw);
-    if normalized.is_empty() {
-        return String::new();
-    }
-
-    if let Some((mapped_type, mapped_subtype)) = map_legacy_entry_type(&normalized) {
-        if !metadata.contains_key("subtype") {
-            metadata.insert(
-                "subtype".to_string(),
-                Value::String(mapped_subtype.to_string()),
-            );
-        }
-        if !metadata.contains_key("_original_type") && original_raw != mapped_type {
-            metadata.insert(
-                "_original_type".to_string(),
-                Value::String(original_raw.to_string()),
-            );
-        }
-        return mapped_type.to_string();
-    }
-
-    if let Some(subtype) = metadata.get_mut("subtype")
-        && let Some(s) = subtype.as_str()
-    {
-        *subtype = Value::String(normalize_subtype_token(s));
-    }
-
-    normalized
-}
-
 /// Canonical secret type options for UI dropdowns.
 pub const SECRET_TYPE_OPTIONS: &[&str] = &[
     "text", "password", "token", "api-key", "ssh-key", "url", "phone", "id-card",
 ];
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use serde_json::{Map, Value};
-
-    #[test]
-    fn normalize_entry_type_maps_legacy_type_and_backfills_metadata() {
-        let mut metadata = Map::new();
-        let normalized = normalize_entry_type_and_metadata("git-server", &mut metadata);
-
-        assert_eq!(normalized, "service");
-        assert_eq!(
-            metadata.get("subtype"),
-            Some(&Value::String("git".to_string()))
-        );
-        assert_eq!(
-            metadata.get("_original_type"),
-            Some(&Value::String("git-server".to_string()))
-        );
-    }
-
-    #[test]
-    fn normalize_entry_type_normalizes_existing_subtype() {
-        let mut metadata = Map::new();
-        metadata.insert(
-            "subtype".to_string(),
-            Value::String("Cloud_API".to_string()),
-        );
-
-        let normalized = normalize_entry_type_and_metadata("service", &mut metadata);
-
-        assert_eq!(normalized, "service");
-        assert_eq!(
-            metadata.get("subtype"),
-            Some(&Value::String("cloud-api".to_string()))
-        );
-    }
-}