feat: add auth_keywords to HubItem and manager_update_hub_auth RPC

- HubItem: new auth_keywords field (serde default=[]) for UI autocomplete
- hub_manager: add update_auth() to update in-memory + persist to DB
- rpc/data: add RpcUpdateHubAuthRequest
- rpc/server: add manager_update_hub_auth handler
- Fix all HubItem struct literals to include auth_keywords field

Author: xz-dev

src/database/mod.rs

@@ -210,6 +210,7 @@ mod tests {
                     hub_icon_url: None,
                 },
                 api_keywords: vec!["owner".to_string(), "repo".to_string()],
+                auth_keywords: vec![],
                 app_url_templates: vec![],
                 target_check_api: None,
             },

src/database/models/hub.rs

@@ -55,6 +55,7 @@ mod tests {
                     hub_icon_url: None,
                 },
                 api_keywords: vec!["owner".to_string(), "repo".to_string()],
+                auth_keywords: vec![],
                 app_url_templates: vec!["https://github.com/%owner/%repo/".to_string()],
                 target_check_api: None,
             },

src/manager/cloud_config_getter.rs

@@ -285,6 +285,7 @@ mod tests {
                 hub_icon_url: None,
             },
             api_keywords: vec!["owner".to_string(), "repo".to_string()],
+            auth_keywords: vec![],
             app_url_templates: templates,
             target_check_api: None,
         }

src/manager/hub_manager.rs

@@ -53,6 +53,20 @@ impl HubManager {
             .any(|h| h.applications_mode_enabled())
     }
 
+    /// Update the auth map for a hub identified by UUID and persist the change.
+    ///
+    /// Returns `false` if no hub with the given UUID exists.
+    pub async fn update_auth(&self, uuid: &str, auth: HashMap<String, String>) -> Result<bool> {
+        let mut hubs = self.hubs.write().await;
+        let hub = match hubs.get_mut(uuid) {
+            Some(h) => h,
+            None => return Ok(false),
+        };
+        hub.auth = auth;
+        get_db().upsert_hub(hub)?;
+        Ok(true)
+    }
+
     /// Return hubs whose api_keywords contain any of the given app_id keys.
     pub async fn hubs_for_app(&self, app_id: &HashMap<String, Option<String>>) -> Vec<HubRecord> {
         let app_keys: Vec<&str> = app_id.keys().map(String::as_str).collect();
@@ -96,6 +110,7 @@ mod tests {
                     hub_icon_url: None,
                 },
                 api_keywords: vec!["owner".to_string(), "repo".to_string()],
+                auth_keywords: vec![],
                 app_url_templates: vec![],
                 target_check_api: None,
             },
@@ -125,4 +140,34 @@ mod tests {
         assert!(deleted);
         assert!(db.load_hubs().unwrap().is_empty());
     }
+
+    #[tokio::test]
+    async fn test_update_auth() {
+        let dir = tempfile::tempdir().unwrap();
+        crate::database::init_db(dir.path()).ok();
+
+        // Insert the hub via HubManager so it is in both the global DB and in-memory state.
+        let mgr = HubManager::load().unwrap();
+        let hub = make_hub("uuid-auth");
+        mgr.upsert_hub(hub).await.unwrap();
+
+        let new_auth: HashMap<String, String> =
+            [("token".to_string(), "ghp_test123".to_string())].into();
+        let ok = mgr
+            .update_auth("uuid-auth", new_auth.clone())
+            .await
+            .unwrap();
+        assert!(ok);
+
+        // Verify in-memory state updated.
+        let updated = mgr.get_hub("uuid-auth").await.unwrap();
+        assert_eq!(updated.auth, new_auth);
+
+        // Returns false for unknown UUID.
+        let not_found = mgr
+            .update_auth("no-such-uuid", HashMap::new())
+            .await
+            .unwrap();
+        assert!(!not_found);
+    }
 }

src/rpc/data.rs

@@ -396,3 +396,16 @@ pub struct RpcCloudConfigApplyRequest {
 pub struct RpcCloudConfigInitRequest {
     pub api_url: String,
 }
+
+/// Request to update the auth map for a hub.
+#[derive(Serialize, Deserialize, Debug)]
+pub struct RpcUpdateHubAuthRequest {
+    pub hub_uuid: String,
+    pub auth: HashMap<String, String>,
+}
+
+impl ToRpcParams for RpcUpdateHubAuthRequest {
+    fn to_rpc_params(self) -> Result<Option<Box<serde_json::value::RawValue>>, serde_json::Error> {
+        to_raw_value(&self).map(Some)
+    }
+}

src/rpc/server.rs

@@ -592,6 +592,19 @@ pub async fn run_server(
         Ok::<bool, ErrorObjectOwned>(true)
     })?;
 
+    // manager_update_hub_auth: Replace the auth map for a hub and persist.
+    module.register_async_method("manager_update_hub_auth", |params, _, _| async move {
+        let request = params.parse::<RpcUpdateHubAuthRequest>()?;
+        let mgr = get_hub_manager().ok_or_else(manager_not_init_err)?;
+        let updated = mgr
+            .read()
+            .await
+            .update_auth(&request.hub_uuid, request.auth)
+            .await
+            .map_err(map_manager_err)?;
+        Ok::<bool, ErrorObjectOwned>(updated)
+    })?;
+
     // manager_delete_hub: Delete a hub by UUID
     module.register_async_method("manager_delete_hub", |params, _, _| async move {
         let request = params.parse::<RpcDeleteHubRequest>()?;

src/websdk/cloud_rules/data/hub_item.rs

@@ -14,6 +14,7 @@ use serde::{Deserialize, Serialize};
 ///   }
 ///   target_check_api: ""
 ///   api_keywords: []
+///   auth_keywords: []
 ///   app_url_templates": []
 /// }
 /// ```
@@ -35,6 +36,11 @@ pub struct HubItem {
     #[serde(rename = "api_keywords", default)]
     pub api_keywords: Vec<String>,
 
+    /// Auth parameter keys required by this hub (e.g. ["token"] for GitHub).
+    /// Used by the UI to provide autocomplete suggestions when editing hub auth.
+    #[serde(rename = "auth_keywords", default)]
+    pub auth_keywords: Vec<String>,
+
     #[serde(rename = "app_url_templates", default)]
     pub app_url_templates: Vec<String>,
 
@@ -85,9 +91,33 @@ mod tests {
         assert_eq!(hub_item.info.hub_icon_url, Some("".to_string()));
         assert_eq!(hub_item.target_check_api, Some("".to_string()));
         assert_eq!(hub_item.api_keywords, ["owner", "repo"]);
+        // Old config without auth_keywords deserializes to empty vec.
+        assert_eq!(hub_item.auth_keywords, Vec::<String>::new());
         assert_eq!(
             hub_item.app_url_templates[0],
             "https://github.com/%owner/%repo/"
         );
     }
+
+    #[test]
+    fn test_hub_item_auth_keywords() {
+        let json = r#"
+{
+  "base_version": 5,
+  "config_version": 3,
+  "uuid": "fd9b2602-62c5-4d55-bd1e-0d6537714ca0",
+  "info": { "hub_name": "GitHub" },
+  "api_keywords": ["owner", "repo"],
+  "auth_keywords": ["token"],
+  "app_url_templates": ["https://github.com/%owner/%repo/"]
+}
+        "#;
+        let hub_item: HubItem = serde_json::from_str(json).unwrap();
+        assert_eq!(hub_item.auth_keywords, ["token"]);
+
+        // Round-trip serialization preserves auth_keywords.
+        let serialized = serde_json::to_string(&hub_item).unwrap();
+        let hub_item2: HubItem = serde_json::from_str(&serialized).unwrap();
+        assert_eq!(hub_item2.auth_keywords, ["token"]);
+    }
 }