enya-agent 0.1.0

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

@@ -0,0 +1,237 @@
+//! Channel runtime — orchestrates channels and routes messages to handlers.
+
+use crate::traits::{Channel, ChannelMessage, SendMessage};
+use async_trait::async_trait;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::sync::{mpsc, Semaphore};
+use tokio::task::JoinHandle;
+
+const DEFAULT_MAX_CONCURRENT: usize = 4;
+const DEFAULT_TIMEOUT_SECS: u64 = 300;
+const TYPING_REFRESH_SECS: u64 = 4;
+const BACKOFF_INITIAL_MS: u64 = 2000;
+const BACKOFF_MAX_MS: u64 = 60000;
+
+/// Handler for processing channel messages.
+#[async_trait]
+pub trait MessageHandler: Send + Sync {
+    /// Process a message and return the response.
+    async fn handle(&self, message: &ChannelMessage) -> anyhow::Result<String>;
+
+    async fn on_start(&self, _message: &ChannelMessage) {}
+    async fn on_complete(&self, _message: &ChannelMessage, _response: &str) {}
+    async fn on_error(&self, _message: &ChannelMessage, _error: &anyhow::Error) {}
+}
+
+/// Runtime configuration.
+#[derive(Debug, Clone)]
+pub struct RuntimeConfig {
+    pub max_concurrent: usize,
+    pub timeout_secs: u64,
+    pub show_typing: bool,
+}
+
+impl Default for RuntimeConfig {
+    fn default() -> Self {
+        Self {
+            max_concurrent: DEFAULT_MAX_CONCURRENT,
+            timeout_secs: DEFAULT_TIMEOUT_SECS,
+            show_typing: true,
+        }
+    }
+}
+
+/// Channel runtime — manages channels and message routing.
+pub struct ChannelRuntime {
+    channels: Vec<Arc<dyn Channel>>,
+    handler: Arc<dyn MessageHandler>,
+    config: RuntimeConfig,
+    shutdown_tx: Option<mpsc::Sender<()>>,
+}
+
+impl ChannelRuntime {
+    pub fn new(handler: impl MessageHandler + 'static) -> Self {
+        Self {
+            channels: Vec::new(),
+            handler: Arc::new(handler),
+            config: RuntimeConfig::default(),
+            shutdown_tx: None,
+        }
+    }
+
+    pub fn with_config(handler: impl MessageHandler + 'static, config: RuntimeConfig) -> Self {
+        Self {
+            channels: Vec::new(),
+            handler: Arc::new(handler),
+            config,
+            shutdown_tx: None,
+        }
+    }
+
+    pub fn add_channel(mut self, channel: impl Channel + 'static) -> Self {
+        self.channels.push(Arc::new(channel));
+        self
+    }
+
+    pub fn add_channel_arc(mut self, channel: Arc<dyn Channel>) -> Self {
+        self.channels.push(channel);
+        self
+    }
+
+    /// Run all channels and process messages.
+    pub async fn run(&mut self) -> anyhow::Result<()> {
+        if self.channels.is_empty() {
+            anyhow::bail!("No channels registered");
+        }
+
+        let (shutdown_tx, mut shutdown_rx) = mpsc::channel::<()>(1);
+        self.shutdown_tx = Some(shutdown_tx);
+
+        let (msg_tx, mut msg_rx) = mpsc::channel::<ChannelMessage>(100);
+
+        // Spawn channel listeners
+        let mut handles: Vec<JoinHandle<()>> = Vec::new();
+        for channel in &self.channels {
+            let handle = spawn_supervised_listener(channel.clone(), msg_tx.clone());
+            handles.push(handle);
+            tracing::info!("Started listener for channel: {}", channel.name());
+        }
+
+        let semaphore = Arc::new(Semaphore::new(self.config.max_concurrent));
+
+        tracing::info!(
+            "Channel runtime started with {} channel(s)",
+            self.channels.len()
+        );
+
+        loop {
+            tokio::select! {
+                Some(message) = msg_rx.recv() => {
+                    let permit = semaphore.clone().acquire_owned().await?;
+                    let handler = self.handler.clone();
+                    let channel = self.find_channel(&message.channel);
+                    let config = self.config.clone();
+
+                    tokio::spawn(async move {
+                        let _permit = permit;
+                        process_message(message, handler, channel, config).await;
+                    });
+                }
+                _ = shutdown_rx.recv() => {
+                    tracing::info!("Channel runtime shutting down");
+                    break;
+                }
+            }
+        }
+
+        for handle in handles {
+            handle.abort();
+        }
+
+        Ok(())
+    }
+
+    pub fn shutdown(&self) {
+        if let Some(ref tx) = self.shutdown_tx {
+            let _ = tx.try_send(());
+        }
+    }
+
+    fn find_channel(&self, name: &str) -> Option<Arc<dyn Channel>> {
+        self.channels.iter().find(|c| c.name() == name).cloned()
+    }
+}
+
+fn spawn_supervised_listener(
+    channel: Arc<dyn Channel>,
+    tx: mpsc::Sender<ChannelMessage>,
+) -> JoinHandle<()> {
+    tokio::spawn(async move {
+        let mut attempt = 0u32;
+        loop {
+            let name = channel.name().to_string();
+            match channel.listen(tx.clone()).await {
+                Ok(()) => break,
+                Err(e) => {
+                    attempt += 1;
+                    let delay = (BACKOFF_INITIAL_MS as f64 * 2.0_f64.powi(attempt as i32 - 1)) as u64;
+                    let delay = delay.min(BACKOFF_MAX_MS);
+                    tracing::warn!("Channel {} failed: {}. Retrying in {}ms", name, e, delay);
+                    tokio::time::sleep(Duration::from_millis(delay)).await;
+                }
+            }
+        }
+    })
+}
+
+async fn process_message(
+    message: ChannelMessage,
+    handler: Arc<dyn MessageHandler>,
+    channel: Option<Arc<dyn Channel>>,
+    config: RuntimeConfig,
+) {
+    let reply_target = message.reply_target.clone();
+
+    handler.on_start(&message).await;
+
+    // Typing indicator
+    let typing_handle = if config.show_typing {
+        channel.as_ref().map(|ch| {
+            let ch = ch.clone();
+            let target = reply_target.clone();
+            tokio::spawn(async move {
+                loop {
+                    let _ = ch.start_typing(&target).await;
+                    tokio::time::sleep(Duration::from_secs(TYPING_REFRESH_SECS)).await;
+                }
+            })
+        })
+    } else {
+        None
+    };
+
+    // Process with timeout
+    let timeout = Duration::from_secs(config.timeout_secs);
+    let result = tokio::time::timeout(timeout, handler.handle(&message)).await;
+
+    // Stop typing
+    if let Some(handle) = typing_handle {
+        handle.abort();
+    }
+    if let Some(ref ch) = channel {
+        let _ = ch.stop_typing(&reply_target).await;
+    }
+
+    // Send response
+    match result {
+        Ok(Ok(response)) => {
+            if let Some(ref ch) = channel {
+                let _ = ch.send(&SendMessage::new(&response, &reply_target)).await;
+            }
+            handler.on_complete(&message, &response).await;
+        }
+        Ok(Err(e)) => {
+            if let Some(ref ch) = channel {
+                let _ = ch.send(&SendMessage::new(format!("Error: {}", e), &reply_target)).await;
+            }
+            handler.on_error(&message, &e).await;
+        }
+        Err(_) => {
+            if let Some(ref ch) = channel {
+                let _ = ch.send(&SendMessage::new("Request timed out", &reply_target)).await;
+            }
+            handler.on_error(&message, &anyhow::anyhow!("Timeout")).await;
+        }
+    }
+}
+
+/// Echo handler for testing.
+pub struct EchoHandler;
+
+#[async_trait]
+impl MessageHandler for EchoHandler {
+    async fn handle(&self, message: &ChannelMessage) -> anyhow::Result<String> {
+        Ok(format!("Echo: {}", message.content))
+    }
+}

package/crates/enact-channels/src/security/mod.rs

@@ -0,0 +1,5 @@
+//! Security modules for channel authentication.
+
+pub mod pairing;
+
+pub use pairing::PairingGuard;

package/crates/enact-channels/src/security/pairing.rs

@@ -0,0 +1,205 @@
+//! Pairing guard for secure channel authentication.
+//!
+//! Simplified from zeroclaw's pairing module.
+
+use parking_lot::Mutex;
+use sha2::{Digest, Sha256};
+use std::collections::HashSet;
+use std::time::{Duration, Instant};
+
+/// Token prefix for generated tokens.
+const TOKEN_PREFIX: &str = "enact_";
+
+/// Maximum failed attempts before lockout.
+const MAX_FAILED_ATTEMPTS: u32 = 5;
+
+/// Lockout duration in seconds.
+const LOCKOUT_DURATION_SECS: u64 = 60;
+
+/// Generate a random pairing code.
+fn generate_pairing_code() -> String {
+    use rand::Rng;
+    let mut rng = rand::thread_rng();
+    let code: String = (0..6).map(|_| rng.gen_range(0..10).to_string()).collect();
+    code
+}
+
+/// Hash a token using SHA-256.
+fn hash_token(token: &str) -> String {
+    let mut hasher = Sha256::new();
+    hasher.update(token.as_bytes());
+    hex::encode(hasher.finalize())
+}
+
+/// Check if a string looks like a token hash (64 hex chars).
+fn is_token_hash(s: &str) -> bool {
+    s.len() == 64 && s.chars().all(|c| c.is_ascii_hexdigit())
+}
+
+/// Pairing guard for secure authentication.
+///
+/// Provides a simple pairing flow:
+/// 1. Generate a pairing code on startup
+/// 2. User sends the code via the channel
+/// 3. A persistent token is issued and stored
+#[derive(Debug)]
+pub struct PairingGuard {
+    /// Whether pairing is required.
+    require_pairing: bool,
+    /// One-time pairing code.
+    pairing_code: Mutex<Option<String>>,
+    /// Set of hashed bearer tokens.
+    paired_tokens: Mutex<HashSet<String>>,
+    /// Brute-force protection: (failed_count, lockout_until).
+    failed_attempts: Mutex<(u32, Option<Instant>)>,
+}
+
+impl PairingGuard {
+    /// Create a new pairing guard.
+    pub fn new(require_pairing: bool, existing_tokens: &[String]) -> Self {
+        let tokens: HashSet<String> = existing_tokens
+            .iter()
+            .map(|t| {
+                if is_token_hash(t) {
+                    t.clone()
+                } else {
+                    hash_token(t)
+                }
+            })
+            .collect();
+
+        let code = if require_pairing && tokens.is_empty() {
+            Some(generate_pairing_code())
+        } else {
+            None
+        };
+
+        Self {
+            require_pairing,
+            pairing_code: Mutex::new(code),
+            paired_tokens: Mutex::new(tokens),
+            failed_attempts: Mutex::new((0, None)),
+        }
+    }
+
+    /// Get the current pairing code (if any).
+    pub fn pairing_code(&self) -> Option<String> {
+        self.pairing_code.lock().clone()
+    }
+
+    /// Check if a user is authorized (by user ID or token).
+    pub fn is_authorized(&self, user_id: &str, allowed_users: &[String]) -> bool {
+        // If pairing is not required, allow all
+        if !self.require_pairing {
+            return true;
+        }
+
+        // Check if user is in allowed list
+        if !allowed_users.is_empty() && !allowed_users.contains(&user_id.to_string()) {
+            return false;
+        }
+
+        // Check if any token is paired
+        !self.paired_tokens.lock().is_empty()
+    }
+
+    /// Attempt to pair with a code.
+    ///
+    /// Returns:
+    /// - `Ok(Some(token))` if pairing succeeded
+    /// - `Ok(None)` if the code was wrong
+    /// - `Err(lockout_secs)` if too many failed attempts
+    pub fn try_pair(&self, code: &str) -> Result<Option<String>, u64> {
+        // Check for lockout
+        {
+            let attempts = self.failed_attempts.lock();
+            if let Some(lockout_until) = attempts.1 {
+                if Instant::now() < lockout_until {
+                    let remaining = lockout_until.duration_since(Instant::now()).as_secs();
+                    return Err(remaining.max(1));
+                }
+            }
+        }
+
+        let mut pairing_code = self.pairing_code.lock();
+
+        if let Some(ref expected) = *pairing_code {
+            if code == expected {
+                // Reset failed attempts on success
+                *self.failed_attempts.lock() = (0, None);
+
+                // Generate a new token
+                let token = format!("{}{}", TOKEN_PREFIX, uuid::Uuid::new_v4());
+                let hash = hash_token(&token);
+
+                // Store the hash
+                self.paired_tokens.lock().insert(hash);
+
+                // Consume the pairing code
+                *pairing_code = None;
+
+                return Ok(Some(token));
+            }
+        }
+
+        // Track failed attempt
+        let mut attempts = self.failed_attempts.lock();
+        attempts.0 += 1;
+
+        if attempts.0 >= MAX_FAILED_ATTEMPTS {
+            let lockout_until = Instant::now() + Duration::from_secs(LOCKOUT_DURATION_SECS);
+            attempts.1 = Some(lockout_until);
+            return Err(LOCKOUT_DURATION_SECS);
+        }
+
+        Ok(None)
+    }
+
+    /// Check if a token is valid.
+    pub fn is_token_valid(&self, token: &str) -> bool {
+        let hash = hash_token(token);
+        self.paired_tokens.lock().contains(&hash)
+    }
+
+    /// Get paired tokens (hashed).
+    pub fn paired_tokens(&self) -> Vec<String> {
+        self.paired_tokens.lock().iter().cloned().collect()
+    }
+}
+
+impl Default for PairingGuard {
+    fn default() -> Self {
+        Self::new(false, &[])
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_pairing_disabled() {
+        let guard = PairingGuard::new(false, &[]);
+        assert!(guard.is_authorized("any_user", &[]));
+        assert!(guard.pairing_code().is_none());
+    }
+
+    #[test]
+    fn test_pairing_flow() {
+        let guard = PairingGuard::new(true, &[]);
+        let code = guard.pairing_code().expect("should have code");
+
+        // Wrong code should fail
+        assert!(matches!(guard.try_pair("wrong"), Ok(None)));
+
+        // Correct code should succeed
+        let token = guard.try_pair(&code).expect("should not be locked").expect("should pair");
+        assert!(token.starts_with(TOKEN_PREFIX));
+
+        // Code should be consumed
+        assert!(guard.pairing_code().is_none());
+
+        // Token should be valid
+        assert!(guard.is_token_valid(&token));
+    }
+}