enya-agent 0.1.0

package/crates/enact-channels/src/whatsapp.rs

@@ -0,0 +1,310 @@
+use crate::traits::{Channel, ChannelMessage, SendMessage};
+use async_trait::async_trait;
+use hmac::{Hmac, Mac};
+use sha2::Sha256;
+use uuid::Uuid;
+
+/// WhatsApp channel using the WhatsApp Business Cloud API.
+///
+/// This channel runs in webhook mode for inbound traffic. `listen` keeps the
+/// runtime alive while webhook handlers push payloads through `parse_webhook_payload`.
+pub struct WhatsAppChannel {
+    access_token: String,
+    endpoint_id: String,
+    verify_token: String,
+    allowed_numbers: Vec<String>,
+}
+
+impl WhatsAppChannel {
+    pub fn new(
+        access_token: String,
+        endpoint_id: String,
+        verify_token: String,
+        allowed_numbers: Vec<String>,
+    ) -> Self {
+        Self {
+            access_token,
+            endpoint_id,
+            verify_token,
+            allowed_numbers,
+        }
+    }
+
+    fn http_client(&self) -> reqwest::Client {
+        crate::config::build_runtime_proxy_client("channel.whatsapp")
+    }
+
+    fn normalize_phone(phone: &str) -> String {
+        if phone.starts_with('+') {
+            phone.to_string()
+        } else {
+            format!("+{phone}")
+        }
+    }
+
+    /// Check if a phone number is allowlisted.
+    fn is_number_allowed(&self, phone: &str) -> bool {
+        self.allowed_numbers.iter().any(|n| n == "*" || n == phone)
+    }
+
+    /// Verify token used by the GET webhook challenge endpoint.
+    pub fn verify_token(&self) -> &str {
+        &self.verify_token
+    }
+
+    /// Parse inbound webhook payload and extract text messages.
+    pub fn parse_webhook_payload(&self, payload: &serde_json::Value) -> Vec<ChannelMessage> {
+        let mut messages = Vec::new();
+
+        let Some(entries) = payload.get("entry").and_then(|e| e.as_array()) else {
+            return messages;
+        };
+
+        for entry in entries {
+            let Some(changes) = entry.get("changes").and_then(|c| c.as_array()) else {
+                continue;
+            };
+
+            for change in changes {
+                let Some(value) = change.get("value") else {
+                    continue;
+                };
+
+                let Some(inbound) = value.get("messages").and_then(|m| m.as_array()) else {
+                    continue;
+                };
+
+                for msg in inbound {
+                    let Some(raw_from) = msg.get("from").and_then(|f| f.as_str()) else {
+                        continue;
+                    };
+
+                    let from = Self::normalize_phone(raw_from);
+                    if !self.is_number_allowed(&from) {
+                        tracing::warn!(
+                            "WhatsApp: ignoring unauthorized sender {}. Add it to allowed_numbers.",
+                            from
+                        );
+                        continue;
+                    }
+
+                    let content = if let Some(text_obj) = msg.get("text") {
+                        text_obj
+                            .get("body")
+                            .and_then(|b| b.as_str())
+                            .unwrap_or("")
+                            .to_string()
+                    } else {
+                        continue;
+                    };
+
+                    if content.is_empty() {
+                        continue;
+                    }
+
+                    let timestamp = msg
+                        .get("timestamp")
+                        .and_then(|t| t.as_str())
+                        .and_then(|t| t.parse::<u64>().ok())
+                        .unwrap_or_else(|| {
+                            std::time::SystemTime::now()
+                                .duration_since(std::time::UNIX_EPOCH)
+                                .unwrap_or_default()
+                                .as_secs()
+                        });
+
+                    messages.push(ChannelMessage {
+                        id: Uuid::new_v4().to_string(),
+                        reply_target: from.clone(),
+                        sender: from,
+                        content,
+                        channel: "whatsapp".to_string(),
+                        timestamp,
+                    });
+                }
+            }
+        }
+
+        messages
+    }
+}
+
+#[async_trait]
+impl Channel for WhatsAppChannel {
+    fn name(&self) -> &str {
+        "whatsapp"
+    }
+
+    async fn send(&self, message: &SendMessage) -> anyhow::Result<()> {
+        let url = format!(
+            "https://graph.facebook.com/v18.0/{}/messages",
+            self.endpoint_id
+        );
+
+        let to = message
+            .recipient
+            .strip_prefix('+')
+            .unwrap_or(&message.recipient);
+
+        let body = serde_json::json!({
+            "messaging_product": "whatsapp",
+            "recipient_type": "individual",
+            "to": to,
+            "type": "text",
+            "text": {
+                "preview_url": false,
+                "body": message.content
+            }
+        });
+
+        let resp = self
+            .http_client()
+            .post(&url)
+            .bearer_auth(&self.access_token)
+            .header("Content-Type", "application/json")
+            .json(&body)
+            .send()
+            .await?;
+
+        if !resp.status().is_success() {
+            let status = resp.status();
+            let error_body = resp.text().await.unwrap_or_default();
+            anyhow::bail!("WhatsApp API error ({}): {}", status, error_body);
+        }
+
+        Ok(())
+    }
+
+    async fn listen(&self, _tx: tokio::sync::mpsc::Sender<ChannelMessage>) -> anyhow::Result<()> {
+        tracing::info!(
+            "WhatsApp channel active (webhook mode). Configure Meta webhook endpoint separately."
+        );
+        loop {
+            tokio::time::sleep(std::time::Duration::from_secs(3600)).await;
+        }
+    }
+
+    async fn health_check(&self) -> bool {
+        let url = format!("https://graph.facebook.com/v18.0/{}", self.endpoint_id);
+        self.http_client()
+            .get(url)
+            .bearer_auth(&self.access_token)
+            .send()
+            .await
+            .map(|r| r.status().is_success())
+            .unwrap_or(false)
+    }
+}
+
+/// Verify the WhatsApp webhook signature (`X-Hub-Signature-256`).
+pub fn verify_whatsapp_signature(app_secret: &str, body: &[u8], signature_header: &str) -> bool {
+    let Some(hex_sig) = signature_header.strip_prefix("sha256=") else {
+        return false;
+    };
+
+    let Ok(expected) = hex::decode(hex_sig) else {
+        return false;
+    };
+
+    let Ok(mut mac) = Hmac::<Sha256>::new_from_slice(app_secret.as_bytes()) else {
+        return false;
+    };
+    mac.update(body);
+    mac.verify_slice(&expected).is_ok()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn make_channel() -> WhatsAppChannel {
+        WhatsAppChannel::new(
+            "test-token".into(),
+            "123456789".into(),
+            "verify-me".into(),
+            vec!["+1234567890".into()],
+        )
+    }
+
+    #[test]
+    fn whatsapp_channel_name() {
+        let ch = make_channel();
+        assert_eq!(ch.name(), "whatsapp");
+    }
+
+    #[test]
+    fn whatsapp_verify_token() {
+        let ch = make_channel();
+        assert_eq!(ch.verify_token(), "verify-me");
+    }
+
+    #[test]
+    fn whatsapp_parse_valid_text_message() {
+        let ch = make_channel();
+        let payload = serde_json::json!({
+            "object": "whatsapp_business_account",
+            "entry": [{
+                "changes": [{
+                    "value": {
+                        "messages": [{
+                            "from": "1234567890",
+                            "timestamp": "1699999999",
+                            "type": "text",
+                            "text": { "body": "Hello Enact!" }
+                        }]
+                    }
+                }]
+            }]
+        });
+
+        let msgs = ch.parse_webhook_payload(&payload);
+        assert_eq!(msgs.len(), 1);
+        assert_eq!(msgs[0].sender, "+1234567890");
+        assert_eq!(msgs[0].content, "Hello Enact!");
+        assert_eq!(msgs[0].channel, "whatsapp");
+    }
+
+    #[test]
+    fn whatsapp_parse_unauthorized_number() {
+        let ch = make_channel();
+        let payload = serde_json::json!({
+            "entry": [{
+                "changes": [{
+                    "value": {
+                        "messages": [{
+                            "from": "9999999999",
+                            "timestamp": "1",
+                            "type": "text",
+                            "text": { "body": "Spam" }
+                        }]
+                    }
+                }]
+            }]
+        });
+
+        let msgs = ch.parse_webhook_payload(&payload);
+        assert!(msgs.is_empty());
+    }
+
+    #[test]
+    fn whatsapp_signature_valid() {
+        let secret = "test_app_secret";
+        let body = b"test payload";
+
+        let mut mac = Hmac::<Sha256>::new_from_slice(secret.as_bytes()).unwrap();
+        mac.update(body);
+        let sig = format!("sha256={}", hex::encode(mac.finalize().into_bytes()));
+
+        assert!(verify_whatsapp_signature(secret, body, &sig));
+    }
+
+    #[test]
+    fn whatsapp_signature_invalid_cases() {
+        let secret = "test_app_secret";
+        let body = b"test payload";
+
+        assert!(!verify_whatsapp_signature(secret, body, ""));
+        assert!(!verify_whatsapp_signature(secret, body, "abc123"));
+        assert!(!verify_whatsapp_signature(secret, body, "sha256=not-valid-hex!!"));
+    }
+}

package/crates/enact-cli/Cargo.toml

@@ -0,0 +1,40 @@
+[package]
+name = "enact"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+description = "Enact CLI - Primary interface for running agents and managing configuration"
+repository.workspace = true
+homepage.workspace = true
+keywords = ["cli", "agent", "ai", "llm", "graph-native"]
+categories.workspace = true
+
+[[bin]]
+name = "enact"
+path = "src/main.rs"
+
+[dependencies]
+enact-core.workspace = true
+enact-config.workspace = true
+enact-providers.workspace = true
+enact-runner.workspace = true
+enact-channels.workspace = true
+enact-gateway.workspace = true
+enact-memory.workspace = true
+
+anyhow.workspace = true
+async-trait.workspace = true
+tokio.workspace = true
+tokio-util.workspace = true
+tracing.workspace = true
+tracing-subscriber = { workspace = true, features = ["env-filter"] }
+serde.workspace = true
+serde_json.workspace = true
+toml.workspace = true
+clap = { version = "4.5", features = ["derive", "env"] }
+clap_complete = "4.5"
+comfy-table = "7.1"
+dirs = "5.0"
+
+[dev-dependencies]
+tempfile.workspace = true

package/crates/enact-cli/src/commands/doctor.rs

@@ -0,0 +1,62 @@
+use comfy_table::Table;
+use std::env;
+
+pub async fn execute() -> anyhow::Result<()> {
+    println!("Enact System Check\n");
+    
+    let mut table = Table::new();
+    table.set_header(vec!["Component", "Status", "Details"]);
+    
+    // Check API keys
+    let openai_key = env::var("OPENAI_API_KEY").is_ok();
+    let azure_key = env::var("AZURE_OPENAI_API_KEY").is_ok();
+    let api_status = if openai_key || azure_key {
+        ("✓".to_string(), "Configured".to_string())
+    } else {
+        ("✗".to_string(), "Missing - set OPENAI_API_KEY or AZURE_OPENAI_API_KEY".to_string())
+    };
+    table.add_row(vec![
+        "API Key",
+        &api_status.0,
+        &api_status.1,
+    ]);
+    
+    // Check WhatsApp config
+    let whatsapp_configured = env::var("WHATSAPP_ACCESS_TOKEN").is_ok() && 
+        env::var("WHATSAPP_ENDPOINT_ID").is_ok() && 
+        env::var("WHATSAPP_VERIFY_TOKEN").is_ok();
+    table.add_row(vec![
+        "WhatsApp",
+        if whatsapp_configured { "✓" } else { "○" },
+        if whatsapp_configured { "Configured" } else { "Optional - not configured" },
+    ]);
+    
+    // Check model configuration
+    let model = env::var("OPENAI_MODEL").unwrap_or_else(|_| "gpt-4o-mini (default)".to_string());
+    table.add_row(vec![
+        "Model",
+        "✓",
+        &model,
+    ]);
+    
+    println!("{}", table);
+    
+    println!("\nEnvironment Variables:");
+    let vars = vec![
+        "OPENAI_API_KEY",
+        "AZURE_OPENAI_API_KEY",
+        "OPENAI_BASE_URL",
+        "OPENAI_MODEL",
+        "WHATSAPP_ACCESS_TOKEN",
+        "WHATSAPP_ENDPOINT_ID",
+        "WHATSAPP_VERIFY_TOKEN",
+        "WHATSAPP_APP_SECRET",
+    ];
+    
+    for var in vars {
+        let status = if env::var(var).is_ok() { "✓ set" } else { "  not set" };
+        println!("  {} {}", status, var);
+    }
+    
+    Ok(())
+}

package/crates/enact-cli/src/commands/mod.rs

@@ -0,0 +1,3 @@
+pub mod doctor;
+pub mod run;
+pub mod serve;

package/crates/enact-cli/src/commands/run.rs

@@ -0,0 +1,69 @@
+use enact_core::callable::LlmCallable;
+use enact_providers::OpenAICompatible;
+use enact_runner::{DefaultAgentRunner, LoopOutcome};
+use std::sync::Arc;
+use tracing::{info, error};
+
+pub async fn execute(
+    input: String,
+    agent_name: String,
+    system_prompt: Option<String>,
+) -> anyhow::Result<()> {
+    info!("Initializing agent '{}'...", agent_name);
+    
+    // Load API key from environment
+    let api_key = std::env::var("OPENAI_API_KEY")
+        .or_else(|_| std::env::var("AZURE_OPENAI_API_KEY"))
+        .map_err(|_| anyhow::anyhow!("No API key found. Set OPENAI_API_KEY or AZURE_OPENAI_API_KEY"))?;
+    
+    let base_url = std::env::var("OPENAI_BASE_URL")
+        .unwrap_or_else(|_| "https://api.openai.com".to_string());
+    
+    let model = std::env::var("OPENAI_MODEL")
+        .unwrap_or_else(|_| "gpt-4o-mini".to_string());
+    
+    // Create provider
+    let provider = Arc::new(OpenAICompatible::new(
+        base_url,
+        model.clone(),
+        Some(api_key),
+    ));
+    
+    // Create callable with system prompt
+    let system = system_prompt.unwrap_or_else(|| {
+        "You are a helpful assistant.".to_string()
+    });
+    
+    let callable = LlmCallable::with_provider(
+        agent_name.clone(),
+        system,
+        provider,
+    );
+    
+    info!("Running agent with model: {}", model);
+    
+    // Create runner and execute
+    let mut runner = DefaultAgentRunner::default_new();
+    
+    match runner.run(&callable, &input).await {
+        Ok(LoopOutcome::Completed(output)) => {
+            println!("\n{}", output);
+        }
+        Ok(LoopOutcome::MaxIterationsReached { last_output, iterations }) => {
+            println!("\n{}", last_output);
+            eprintln!("\nWarning: Max iterations ({}) reached", iterations);
+        }
+        Ok(LoopOutcome::Cancelled) => {
+            eprintln!("Execution cancelled");
+        }
+        Ok(LoopOutcome::TimedOut { elapsed_secs }) => {
+            eprintln!("Execution timed out after {} seconds", elapsed_secs);
+        }
+        Err(e) => {
+            error!("Execution failed: {}", e);
+            return Err(e);
+        }
+    }
+    
+    Ok(())
+}

package/crates/enact-cli/src/commands/serve.rs

@@ -0,0 +1,81 @@
+use enact_channels::WhatsAppChannel;
+use enact_gateway::{serve as start_gateway, GatewayConfig, GatewayState, RunnerResponder};
+use enact_core::callable::LlmCallable;
+use enact_providers::OpenAICompatible;
+use std::sync::Arc;
+use tracing::info;
+
+pub async fn execute(http_port: u16, air_gapped: bool) -> anyhow::Result<()> {
+    if air_gapped {
+        info!("Running in air-gapped mode - external network calls disabled");
+    }
+    
+    // Check for WhatsApp configuration
+    let whatsapp_config = match (
+        std::env::var("WHATSAPP_ACCESS_TOKEN"),
+        std::env::var("WHATSAPP_ENDPOINT_ID"),
+        std::env::var("WHATSAPP_VERIFY_TOKEN"),
+    ) {
+        (Ok(token), Ok(endpoint), Ok(verify)) => {
+            info!("WhatsApp channel configured");
+            Some((token, endpoint, verify))
+        }
+        _ => {
+            info!("WhatsApp not configured - webhook endpoints will not be available");
+            None
+        }
+    };
+    
+    if let Some((access_token, endpoint_id, verify_token)) = whatsapp_config {
+        // Create WhatsApp channel
+        let allowed_numbers = std::env::var("WHATSAPP_ALLOWED_NUMBERS")
+            .ok()
+            .map(|v| v.split(',').map(|s| s.trim().to_string()).collect())
+            .unwrap_or_else(|| vec!["*".to_string()]);
+        
+        let whatsapp = Arc::new(WhatsAppChannel::new(
+            access_token,
+            endpoint_id,
+            verify_token,
+            allowed_numbers,
+        ));
+        
+        // Create callable for handling messages
+        let api_key = std::env::var("OPENAI_API_KEY").ok();
+        let responder: Arc<dyn enact_gateway::InboundResponder> = if let Some(key) = api_key {
+            let base_url = std::env::var("OPENAI_BASE_URL")
+                .unwrap_or_else(|_| "https://api.openai.com".to_string());
+            let model = std::env::var("OPENAI_MODEL")
+                .unwrap_or_else(|_| "gpt-4o-mini".to_string());
+            
+            let provider = Arc::new(OpenAICompatible::new(base_url, model, Some(key)));
+            let callable = LlmCallable::with_provider(
+                "whatsapp_agent",
+                "You are a helpful WhatsApp assistant. Keep responses concise.",
+                provider,
+            );
+            
+            Arc::new(RunnerResponder::new(Arc::new(callable)))
+        } else {
+            // Fallback to echo responder if no API key
+            Arc::new(enact_gateway::EchoResponder)
+        };
+        
+        let app_secret = std::env::var("WHATSAPP_APP_SECRET").ok();
+        
+        let config = GatewayConfig {
+            host: "0.0.0.0".to_string(),
+            port: http_port,
+            ..Default::default()
+        };
+        
+        let state = GatewayState::new(whatsapp, app_secret, responder, &config);
+        
+        info!("Starting gateway server on port {}", http_port);
+        start_gateway(config, state).await?;
+    } else {
+        anyhow::bail!("No channels configured. Set WhatsApp environment variables to start server.");
+    }
+    
+    Ok(())
+}

package/crates/enact-cli/src/config.rs

@@ -0,0 +1,2 @@
+// Configuration loading and management
+// TODO: Implement config file loading (TOML/JSON)

package/crates/enact-cli/src/main.rs

@@ -0,0 +1,79 @@
+use clap::{Parser, Subcommand};
+use tracing::info;
+
+mod commands;
+mod config;
+
+use commands::{run, serve};
+
+#[derive(Parser)]
+#[command(name = "enact")]
+#[command(about = "Enact CLI - Run agents, manage configuration, and start servers")]
+#[command(version)]
+struct Cli {
+    #[command(subcommand)]
+    command: Commands,
+}
+
+#[derive(Subcommand)]
+enum Commands {
+    /// Execute an agent once with given input
+    Run {
+        /// Input to send to the agent
+        #[arg(short, long)]
+        input: String,
+        
+        /// Agent name
+        #[arg(short, long, default_value = "assistant")]
+        agent: String,
+        
+        /// System prompt override
+        #[arg(long)]
+        system_prompt: Option<String>,
+    },
+    
+    /// Start HTTP/gRPC server for API access
+    Serve {
+        /// HTTP port for REST/webhook endpoints
+        #[arg(long, default_value = "8080")]
+        http_port: u16,
+        
+        /// Run in air-gapped mode (no external network)
+        #[arg(long)]
+        air_gapped: bool,
+    },
+    
+    /// Check configuration and system status
+    Doctor,
+    
+    /// Show version information
+    Version,
+}
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    tracing_subscriber::fmt()
+        .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
+        .init();
+    
+    let cli = Cli::parse();
+    
+    match cli.command {
+        Commands::Run { input, agent, system_prompt } => {
+            info!("Running agent '{}' with input: {}", agent, input);
+            run::execute(input, agent, system_prompt).await?;
+        }
+        Commands::Serve { http_port, air_gapped } => {
+            info!("Starting server on port {} (air_gapped: {})", http_port, air_gapped);
+            serve::execute(http_port, air_gapped).await?;
+        }
+        Commands::Doctor => {
+            commands::doctor::execute().await?;
+        }
+        Commands::Version => {
+            println!("enact {}", env!("CARGO_PKG_VERSION"));
+        }
+    }
+    
+    Ok(())
+}

package/crates/enact-config/Cargo.toml

@@ -0,0 +1,36 @@
+[package]
+name = "enact-config"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+description = "Unified configuration management for Enact - secure storage with keychain and encrypted files"
+repository.workspace = true
+homepage.workspace = true
+keywords = ["config", "security", "encryption", "keychain"]
+categories.workspace = true
+
+[dependencies]
+tokio.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+toml.workspace = true
+aes-gcm.workspace = true
+rand.workspace = true
+dirs.workspace = true
+hex.workspace = true
+reqwest = { workspace = true, features = ["json"] }
+chrono = { workspace = true, features = ["serde"] }
+thiserror.workspace = true
+anyhow.workspace = true
+tracing.workspace = true
+dotenv = "0.15.0"
+
+[dev-dependencies]
+tempfile.workspace = true
+tokio = { workspace = true, features = ["test-util"] }
+tracing-subscriber.workspace = true
+
+[[example]]
+name = "test-env-vars"
+path = "examples/test-env-vars.rs"
+