feat(hooks): implement HTTP hook handler

Author: quangdang46

src/cli/commands.rs

@@ -359,7 +359,7 @@ pub fn run_mcp_list_command(json: bool) -> Result<()> {
 }
 
 use crate::cli::args::HooksCommand;
-use crate::hooks::config::{HookEvent, HookHandlerConfig};
+use crate::hooks::config::{HookEvent, HookHandlerConfig, HttpHandlerConfig};
 
 pub async fn run_hooks_command(args: HooksCommand) -> Result<()> {
     match args {
@@ -402,11 +402,8 @@ fn parse_hook_event(event_str: &str) -> Result<HookEvent> {
         .ok_or_else(|| anyhow::anyhow!("Invalid event name '{}'. Valid events: pre_tool_use, post_tool_use, pre_session, post_session, error, custom:<name>", event_str))
 }
 
-fn parse_handler_type(handler_type: &str) -> Result<HookHandlerConfig> {
-    match handler_type.to_ascii_lowercase().as_str() {
-        "command" => Ok(HookHandlerConfig::default()),
-        _ => anyhow::bail!("Invalid handler type '{}'. Valid types: command", handler_type),
-    }
+fn parse_handler_type(_handler_type: &str) -> Result<HookHandlerConfig> {
+    anyhow::bail!("parse_handler_type is deprecated; use handler type specific parsing in run_hooks_add")
 }
 
 async fn run_hooks_list(event: Option<String>) -> Result<()> {
@@ -433,10 +430,20 @@ async fn run_hooks_list(event: Option<String>) -> Result<()> {
             printed_header = true;
         }
 
-        println!(
-            "[{}] command=\"{}\" timeout={:?}",
-            event_name, handler.command, handler.timeout_secs
-        );
+        match handler {
+            HookHandlerConfig::Command(cmd) => {
+                println!(
+                    "[{}] type=command command=\"{}\" timeout={:?}",
+                    event_name, cmd.command, cmd.timeout_secs
+                );
+            }
+            HookHandlerConfig::Http(http) => {
+                println!(
+                    "[{}] type=http url=\"{}\" method={} timeout={:?}",
+                    event_name, http.url, http.method, http.timeout_secs
+                );
+            }
+        }
     }
 
     if !printed_header && event.is_some() {
@@ -447,36 +454,57 @@ async fn run_hooks_list(event: Option<String>) -> Result<()> {
 }
 
 async fn run_hooks_add(event: String, handler_type: String, config_json: String) -> Result<()> {
-    // Parse event
     let hook_event = parse_hook_event(&event)?;
     let event_key = match &hook_event {
         HookEvent::Custom(name) => format!("custom:{}", name),
         other => format!("{:?}", other).to_lowercase(),
     };
 
-    // Parse handler type
-    let mut handler = parse_handler_type(&handler_type)?;
-    
-    // Parse config JSON to extract command
     let config: serde_json::Value = serde_json::from_str(&config_json)
         .with_context(|| format!("Failed to parse config JSON: {}", config_json))?;
 
-    // Extract command (required)
-    let command = config
-        .get("command")
-        .and_then(|v| v.as_str())
-        .ok_or_else(|| anyhow::anyhow!("Config JSON must include 'command' field"))?;
-    handler.command = command.to_string();
-    
-    // Extract optional args
-    if let Some(args) = config.get("args").and_then(|v| v.as_array()) {
-        handler.args = args
-            .iter()
-            .filter_map(|v| v.as_str().map(String::from))
-            .collect();
-    }
+    let handler = match handler_type.to_ascii_lowercase().as_str() {
+        "command" => {
+            let command = config
+                .get("command")
+                .and_then(|v| v.as_str())
+                .ok_or_else(|| anyhow::anyhow!("Config JSON must include 'command' field"))?;
+            let mut handler = crate::hooks::config::CommandHandlerConfig::default();
+            handler.command = command.to_string();
+            if let Some(args) = config.get("args").and_then(|v| v.as_array()) {
+                handler.args = args
+                    .iter()
+                    .filter_map(|v| v.as_str().map(String::from))
+                    .collect();
+            }
+            HookHandlerConfig::Command(handler)
+        }
+        "http" => {
+            let url = config
+                .get("url")
+                .and_then(|v| v.as_str())
+                .ok_or_else(|| anyhow::anyhow!("Config JSON must include 'url' field"))?;
+            let method = config
+                .get("method")
+                .and_then(|v| v.as_str())
+                .unwrap_or("GET");
+            let mut handler = HttpHandlerConfig::default();
+            handler.url = url.to_string();
+            handler.method = method.to_string();
+            if let Some(headers) = config.get("headers").and_then(|v| v.as_object()) {
+                handler.headers = headers
+                    .iter()
+                    .filter_map(|(k, v)| v.as_str().map(|s| (k.clone(), s.to_string())))
+                    .collect();
+            }
+            if let Some(body) = config.get("body") {
+                handler.body = Some(body.clone());
+            }
+            HookHandlerConfig::Http(handler)
+        }
+        _ => anyhow::bail!("Invalid handler type '{}'. Valid types: command, http", handler_type),
+    };
 
-    // Load existing config and add the new hook
     let mut config = load_user_hooks_config()?;
     config.events.insert(event_key.clone(), handler);
     save_user_hooks_config(&config)?;

src/hooks/config.rs

@@ -53,8 +53,22 @@ impl HookEvent {
 
 /// Handler configuration for a single hook
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "lowercase")]
+pub enum HookHandlerConfig {
+    Command(CommandHandlerConfig),
+    Http(HttpHandlerConfig),
+}
+
+impl Default for HookHandlerConfig {
+    fn default() -> Self {
+        HookHandlerConfig::Command(CommandHandlerConfig::default())
+    }
+}
+
+/// Command handler configuration
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(default)]
-pub struct HookHandlerConfig {
+pub struct CommandHandlerConfig {
     /// The command or script to execute
     pub command: String,
     /// Arguments to pass to the handler
@@ -71,7 +85,7 @@ pub struct HookHandlerConfig {
     pub pass_input_via_stdin: bool,
 }
 
-impl Default for HookHandlerConfig {
+impl Default for CommandHandlerConfig {
     fn default() -> Self {
         Self {
             command: String::new(),
@@ -84,6 +98,36 @@ impl Default for HookHandlerConfig {
     }
 }
 
+/// HTTP handler configuration
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(default)]
+pub struct HttpHandlerConfig {
+    /// URL to send the HTTP request to
+    pub url: String,
+    /// HTTP method (GET, POST, PUT, DELETE, etc.)
+    pub method: String,
+    /// HTTP headers
+    #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
+    pub headers: BTreeMap<String, String>,
+    /// Request body template
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub body: Option<serde_json::Value>,
+    /// Timeout in seconds (default: 30)
+    pub timeout_secs: Option<u64>,
+}
+
+impl Default for HttpHandlerConfig {
+    fn default() -> Self {
+        Self {
+            url: String::new(),
+            method: "GET".to_string(),
+            headers: BTreeMap::new(),
+            body: None,
+            timeout_secs: Some(30),
+        }
+    }
+}
+
 /// Hooks configuration containing mappings of events to their handlers
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 #[serde(default)]
@@ -207,39 +251,39 @@ mod tests {
         let mut config1 = HooksConfig::default();
         config1.events.insert(
             "pre_tool_use".to_string(),
-            HookHandlerConfig {
+            HookHandlerConfig::Command(CommandHandlerConfig {
                 command: "user_handler".to_string(),
                 ..Default::default()
-            },
+            }),
         );
 
         let mut config2 = HooksConfig::default();
         config2.events.insert(
             "pre_tool_use".to_string(),
-            HookHandlerConfig {
+            HookHandlerConfig::Command(CommandHandlerConfig {
                 command: "project_handler".to_string(),
                 ..Default::default()
-            },
+            }),
         );
         config2.events.insert(
             "post_tool_use".to_string(),
-            HookHandlerConfig {
+            HookHandlerConfig::Command(CommandHandlerConfig {
                 command: "post_handler".to_string(),
                 ..Default::default()
-            },
+            }),
         );
 
         config1.merge(config2);
 
-        // Project handler should override user handler
-        assert_eq!(
-            config1.events.get("pre_tool_use").unwrap().command,
-            "project_handler"
+        let pre_handler = config1.events.get("pre_tool_use").unwrap();
+        let post_handler = config1.events.get("post_tool_use").unwrap();
+        assert!(
+            matches!(pre_handler, HookHandlerConfig::Command(cmd) if cmd.command == "project_handler"),
+            "Project handler should override user handler"
         );
-        // New event should be added
-        assert_eq!(
-            config1.events.get("post_tool_use").unwrap().command,
-            "post_handler"
+        assert!(
+            matches!(post_handler, HookHandlerConfig::Command(cmd) if cmd.command == "post_handler"),
+            "New event should be added"
         );
     }