enya-agent 0.1.0

package/crates/enact-cron/src/types.rs

@@ -0,0 +1,148 @@
+//! Cron job types and data structures
+
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+
+/// Type of job to execute
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
+#[serde(rename_all = "lowercase")]
+pub enum JobType {
+    #[default]
+    Shell,
+    Agent,
+}
+
+impl JobType {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Self::Shell => "shell",
+            Self::Agent => "agent",
+        }
+    }
+
+    pub fn parse(raw: &str) -> Self {
+        if raw.eq_ignore_ascii_case("agent") {
+            Self::Agent
+        } else {
+            Self::Shell
+        }
+    }
+}
+
+/// Session target for agent jobs
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
+#[serde(rename_all = "lowercase")]
+pub enum SessionTarget {
+    #[default]
+    Isolated,
+    Main,
+}
+
+impl SessionTarget {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Self::Isolated => "isolated",
+            Self::Main => "main",
+        }
+    }
+
+    pub fn parse(raw: &str) -> Self {
+        if raw.eq_ignore_ascii_case("main") {
+            Self::Main
+        } else {
+            Self::Isolated
+        }
+    }
+}
+
+/// Schedule definition for cron jobs
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(tag = "kind", rename_all = "lowercase")]
+pub enum Schedule {
+    /// Standard cron expression (5, 6, or 7 fields)
+    Cron {
+        expr: String,
+        #[serde(default)]
+        tz: Option<String>,
+    },
+    /// One-shot execution at a specific time
+    At { at: DateTime<Utc> },
+    /// Interval-based execution
+    Every { every_ms: u64 },
+}
+
+/// Configuration for job output delivery
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct DeliveryConfig {
+    #[serde(default)]
+    pub mode: String,
+    #[serde(default)]
+    pub channel: Option<String>,
+    #[serde(default)]
+    pub to: Option<String>,
+    #[serde(default = "default_true")]
+    pub best_effort: bool,
+}
+
+impl Default for DeliveryConfig {
+    fn default() -> Self {
+        Self {
+            mode: "none".to_string(),
+            channel: None,
+            to: None,
+            best_effort: true,
+        }
+    }
+}
+
+fn default_true() -> bool {
+    true
+}
+
+/// A scheduled cron job
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CronJob {
+    pub id: String,
+    pub expression: String,
+    pub schedule: Schedule,
+    pub command: String,
+    pub prompt: Option<String>,
+    pub name: Option<String>,
+    pub job_type: JobType,
+    pub session_target: SessionTarget,
+    pub model: Option<String>,
+    pub enabled: bool,
+    pub delivery: DeliveryConfig,
+    pub delete_after_run: bool,
+    pub created_at: DateTime<Utc>,
+    pub next_run: DateTime<Utc>,
+    pub last_run: Option<DateTime<Utc>>,
+    pub last_status: Option<String>,
+    pub last_output: Option<String>,
+}
+
+/// Record of a job execution
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CronRun {
+    pub id: i64,
+    pub job_id: String,
+    pub started_at: DateTime<Utc>,
+    pub finished_at: DateTime<Utc>,
+    pub status: String,
+    pub output: Option<String>,
+    pub duration_ms: Option<i64>,
+}
+
+/// Patch for updating a cron job
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct CronJobPatch {
+    pub schedule: Option<Schedule>,
+    pub command: Option<String>,
+    pub prompt: Option<String>,
+    pub name: Option<String>,
+    pub enabled: Option<bool>,
+    pub delivery: Option<DeliveryConfig>,
+    pub model: Option<String>,
+    pub session_target: Option<SessionTarget>,
+    pub delete_after_run: Option<bool>,
+}

package/crates/enact-gateway/Cargo.toml

@@ -0,0 +1,31 @@
+[package]
+name = "enact-gateway"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+description = "Thin secure webhook gateway for Enact channels"
+repository.workspace = true
+homepage.workspace = true
+keywords = ["gateway", "webhook", "server", "http"]
+categories.workspace = true
+
+[dependencies]
+enact-channels.workspace = true
+enact-core.workspace = true
+enact-runner.workspace = true
+anyhow.workspace = true
+async-trait.workspace = true
+axum = "0.7"
+serde.workspace = true
+serde_json.workspace = true
+sha2.workspace = true
+hex.workspace = true
+tokio.workspace = true
+tower = { version = "0.5", features = ["util"] }
+tower-http = { version = "0.5", features = ["limit", "timeout"] }
+tracing.workspace = true
+tracing-subscriber.workspace = true
+
+[dev-dependencies]
+tokio.workspace = true
+hmac = "0.12"

package/crates/enact-gateway/README.md

@@ -0,0 +1,30 @@
+# enact-gateway
+
+Thin, local-first HTTP ingress for Enact channels.
+
+Use `RunnerResponder` to route inbound channel messages through `enact-runner`
+and a real `Callable`, or `EchoResponder` for lightweight testing.
+
+## Current endpoints
+
+- `GET /health` - basic liveness
+- `GET /webhook/whatsapp` - Meta webhook challenge verification
+- `POST /webhook/whatsapp` - WhatsApp webhook ingestion
+
+## Security defaults
+
+- Request body limit: 64 KB
+- Request timeout: 30 seconds
+- Optional WhatsApp signature verification via `X-Hub-Signature-256`
+- Sliding-window rate limiting per client key
+- Idempotency deduplication via `X-Idempotency-Key` or request-body hash fallback
+
+## Example
+
+```bash
+WHATSAPP_ACCESS_TOKEN="..." \
+WHATSAPP_ENDPOINT_ID="..." \
+WHATSAPP_VERIFY_TOKEN="..." \
+WHATSAPP_APP_SECRET="..." \
+cargo run -p enact-gateway --example whatsapp-gateway
+```

package/crates/enact-gateway/examples/whatsapp-gateway-runner-mock.rs

@@ -0,0 +1,59 @@
+use enact_channels::WhatsAppChannel;
+use enact_core::callable::Callable;
+use enact_gateway::{GatewayConfig, GatewayState, RunnerResponder, serve};
+use async_trait::async_trait;
+use std::sync::Arc;
+
+struct MockCallable;
+
+#[async_trait]
+impl Callable for MockCallable {
+    fn name(&self) -> &str {
+        "gateway_mock_callable"
+    }
+
+    async fn run(&self, input: &str) -> anyhow::Result<String> {
+        Ok(format!("runner-mock response: {input}"))
+    }
+}
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    tracing_subscriber::fmt().init();
+
+    let access_token = std::env::var("WHATSAPP_ACCESS_TOKEN")?;
+    let endpoint_id = std::env::var("WHATSAPP_ENDPOINT_ID")?;
+    let verify_token = std::env::var("WHATSAPP_VERIFY_TOKEN")?;
+    let app_secret = std::env::var("WHATSAPP_APP_SECRET").ok();
+
+    let allowed_numbers = std::env::var("WHATSAPP_ALLOWED_NUMBERS")
+        .ok()
+        .map(|value| {
+            value
+                .split(',')
+                .map(|entry| entry.trim().to_string())
+                .filter(|entry| !entry.is_empty())
+                .collect::<Vec<_>>()
+        })
+        .unwrap_or_else(|| vec!["*".to_string()]);
+
+    let whatsapp = Arc::new(WhatsAppChannel::new(
+        access_token,
+        endpoint_id,
+        verify_token,
+        allowed_numbers,
+    ));
+
+    let callable: Arc<dyn Callable> = Arc::new(MockCallable);
+    let responder = Arc::new(RunnerResponder::new(callable));
+
+    let mut cfg = GatewayConfig::default();
+    if let Ok(port) = std::env::var("GATEWAY_PORT") {
+        if let Ok(parsed) = port.parse::<u16>() {
+            cfg.port = parsed;
+        }
+    }
+
+    let state = GatewayState::new(whatsapp, app_secret, responder, &cfg);
+    serve(cfg, state).await
+}

package/crates/enact-gateway/examples/whatsapp-gateway.rs

@@ -0,0 +1,42 @@
+use enact_channels::WhatsAppChannel;
+use enact_gateway::{EchoResponder, GatewayConfig, GatewayState, serve};
+use std::sync::Arc;
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    tracing_subscriber::fmt()
+        .init();
+
+    let access_token = std::env::var("WHATSAPP_ACCESS_TOKEN")?;
+    let endpoint_id = std::env::var("WHATSAPP_ENDPOINT_ID")?;
+    let verify_token = std::env::var("WHATSAPP_VERIFY_TOKEN")?;
+    let app_secret = std::env::var("WHATSAPP_APP_SECRET").ok();
+
+    let allowed_numbers = std::env::var("WHATSAPP_ALLOWED_NUMBERS")
+        .ok()
+        .map(|value| {
+            value
+                .split(',')
+                .map(|entry| entry.trim().to_string())
+                .filter(|entry| !entry.is_empty())
+                .collect::<Vec<_>>()
+        })
+        .unwrap_or_else(|| vec!["*".to_string()]);
+
+    let whatsapp = Arc::new(WhatsAppChannel::new(
+        access_token,
+        endpoint_id,
+        verify_token,
+        allowed_numbers,
+    ));
+
+    let mut cfg = GatewayConfig::default();
+    if let Ok(port) = std::env::var("GATEWAY_PORT") {
+        if let Ok(parsed) = port.parse::<u16>() {
+            cfg.port = parsed;
+        }
+    }
+
+    let state = GatewayState::new(whatsapp, app_secret, Arc::new(EchoResponder), &cfg);
+    serve(cfg, state).await
+}