enya-agent 0.1.0

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

@@ -0,0 +1,589 @@
+//! SQLite-based storage for cron jobs
+
+use crate::schedule::{next_run_for_schedule, schedule_cron_expression, validate_schedule};
+use crate::types::{
+    CronJob, CronJobPatch, CronRun, DeliveryConfig, JobType, Schedule, SessionTarget,
+};
+use anyhow::{Context, Result};
+use chrono::{DateTime, Utc};
+use rusqlite::{params, Connection};
+use std::path::Path;
+use uuid::Uuid;
+
+const MAX_CRON_OUTPUT_BYTES: usize = 16 * 1024;
+const TRUNCATED_OUTPUT_MARKER: &str = "\n...[truncated]";
+
+/// Cron job store
+pub struct CronStore {
+    db_path: std::path::PathBuf,
+    max_run_history: u32,
+    max_tasks: usize,
+}
+
+impl CronStore {
+    /// Create a new cron store
+    pub fn new(workspace_dir: &Path, max_run_history: u32, max_tasks: usize) -> Result<Self> {
+        let db_path = workspace_dir.join("cron").join("jobs.db");
+        if let Some(parent) = db_path.parent() {
+            std::fs::create_dir_all(parent)
+                .with_context(|| format!("Failed to create cron directory: {}", parent.display()))?;
+        }
+
+        let store = Self {
+            db_path,
+            max_run_history,
+            max_tasks,
+        };
+
+        // Initialize schema
+        store.with_connection(|_| Ok(()))?;
+
+        Ok(store)
+    }
+
+    /// Add a simple shell job with cron expression
+    pub fn add_job(&self, expression: &str, command: &str) -> Result<CronJob> {
+        let schedule = Schedule::Cron {
+            expr: expression.to_string(),
+            tz: None,
+        };
+        self.add_shell_job(None, schedule, command)
+    }
+
+    /// Add a shell job with a custom schedule
+    pub fn add_shell_job(
+        &self,
+        name: Option<String>,
+        schedule: Schedule,
+        command: &str,
+    ) -> Result<CronJob> {
+        let now = Utc::now();
+        validate_schedule(&schedule, now)?;
+        let next_run = next_run_for_schedule(&schedule, now)?;
+        let id = Uuid::new_v4().to_string();
+        let expression = schedule_cron_expression(&schedule).unwrap_or_default();
+        let schedule_json = serde_json::to_string(&schedule)?;
+
+        self.with_connection(|conn| {
+            conn.execute(
+                "INSERT INTO cron_jobs (
+                    id, expression, command, schedule, job_type, prompt, name, session_target, model,
+                    enabled, delivery, delete_after_run, created_at, next_run
+                 ) VALUES (?1, ?2, ?3, ?4, 'shell', NULL, ?5, 'isolated', NULL, 1, ?6, 0, ?7, ?8)",
+                params![
+                    id,
+                    expression,
+                    command,
+                    schedule_json,
+                    name,
+                    serde_json::to_string(&DeliveryConfig::default())?,
+                    now.to_rfc3339(),
+                    next_run.to_rfc3339(),
+                ],
+            )
+            .context("Failed to insert cron shell job")?;
+            Ok(())
+        })?;
+
+        self.get_job(&id)
+    }
+
+    /// Add an agent job
+    #[allow(clippy::too_many_arguments)]
+    pub fn add_agent_job(
+        &self,
+        name: Option<String>,
+        schedule: Schedule,
+        prompt: &str,
+        session_target: SessionTarget,
+        model: Option<String>,
+        delivery: Option<DeliveryConfig>,
+        delete_after_run: bool,
+    ) -> Result<CronJob> {
+        let now = Utc::now();
+        validate_schedule(&schedule, now)?;
+        let next_run = next_run_for_schedule(&schedule, now)?;
+        let id = Uuid::new_v4().to_string();
+        let expression = schedule_cron_expression(&schedule).unwrap_or_default();
+        let schedule_json = serde_json::to_string(&schedule)?;
+        let delivery = delivery.unwrap_or_default();
+
+        self.with_connection(|conn| {
+            conn.execute(
+                "INSERT INTO cron_jobs (
+                    id, expression, command, schedule, job_type, prompt, name, session_target, model,
+                    enabled, delivery, delete_after_run, created_at, next_run
+                 ) VALUES (?1, ?2, '', ?3, 'agent', ?4, ?5, ?6, ?7, 1, ?8, ?9, ?10, ?11)",
+                params![
+                    id,
+                    expression,
+                    schedule_json,
+                    prompt,
+                    name,
+                    session_target.as_str(),
+                    model,
+                    serde_json::to_string(&delivery)?,
+                    if delete_after_run { 1 } else { 0 },
+                    now.to_rfc3339(),
+                    next_run.to_rfc3339(),
+                ],
+            )
+            .context("Failed to insert cron agent job")?;
+            Ok(())
+        })?;
+
+        self.get_job(&id)
+    }
+
+    /// List all jobs
+    pub fn list_jobs(&self) -> Result<Vec<CronJob>> {
+        self.with_connection(|conn| {
+            let mut stmt = conn.prepare(
+                "SELECT id, expression, command, schedule, job_type, prompt, name, session_target, model,
+                        enabled, delivery, delete_after_run, created_at, next_run, last_run, last_status, last_output
+                 FROM cron_jobs ORDER BY next_run ASC",
+            )?;
+
+            let rows = stmt.query_map([], map_cron_job_row)?;
+
+            let mut jobs = Vec::new();
+            for row in rows {
+                jobs.push(row?);
+            }
+            Ok(jobs)
+        })
+    }
+
+    /// Get a job by ID
+    pub fn get_job(&self, job_id: &str) -> Result<CronJob> {
+        self.with_connection(|conn| {
+            let mut stmt = conn.prepare(
+                "SELECT id, expression, command, schedule, job_type, prompt, name, session_target, model,
+                        enabled, delivery, delete_after_run, created_at, next_run, last_run, last_status, last_output
+                 FROM cron_jobs WHERE id = ?1",
+            )?;
+
+            let mut rows = stmt.query(params![job_id])?;
+            if let Some(row) = rows.next()? {
+                map_cron_job_row(row).map_err(Into::into)
+            } else {
+                anyhow::bail!("Cron job '{job_id}' not found")
+            }
+        })
+    }
+
+    /// Remove a job
+    pub fn remove_job(&self, id: &str) -> Result<()> {
+        let changed = self.with_connection(|conn| {
+            conn.execute("DELETE FROM cron_jobs WHERE id = ?1", params![id])
+                .context("Failed to delete cron job")
+        })?;
+
+        if changed == 0 {
+            anyhow::bail!("Cron job '{id}' not found");
+        }
+
+        Ok(())
+    }
+
+    /// Get jobs that are due to run
+    pub fn due_jobs(&self, now: DateTime<Utc>) -> Result<Vec<CronJob>> {
+        let lim = i64::try_from(self.max_tasks.max(1))
+            .context("max_tasks overflows i64")?;
+        self.with_connection(|conn| {
+            let mut stmt = conn.prepare(
+                "SELECT id, expression, command, schedule, job_type, prompt, name, session_target, model,
+                        enabled, delivery, delete_after_run, created_at, next_run, last_run, last_status, last_output
+                 FROM cron_jobs
+                 WHERE enabled = 1 AND next_run <= ?1
+                 ORDER BY next_run ASC
+                 LIMIT ?2",
+            )?;
+
+            let rows = stmt.query_map(params![now.to_rfc3339(), lim], map_cron_job_row)?;
+
+            let mut jobs = Vec::new();
+            for row in rows {
+                jobs.push(row?);
+            }
+            Ok(jobs)
+        })
+    }
+
+    /// Update a job
+    pub fn update_job(&self, job_id: &str, patch: CronJobPatch) -> Result<CronJob> {
+        let mut job = self.get_job(job_id)?;
+        let mut schedule_changed = false;
+
+        if let Some(schedule) = patch.schedule {
+            validate_schedule(&schedule, Utc::now())?;
+            job.schedule = schedule;
+            job.expression = schedule_cron_expression(&job.schedule).unwrap_or_default();
+            schedule_changed = true;
+        }
+        if let Some(command) = patch.command {
+            job.command = command;
+        }
+        if let Some(prompt) = patch.prompt {
+            job.prompt = Some(prompt);
+        }
+        if let Some(name) = patch.name {
+            job.name = Some(name);
+        }
+        if let Some(enabled) = patch.enabled {
+            job.enabled = enabled;
+        }
+        if let Some(delivery) = patch.delivery {
+            job.delivery = delivery;
+        }
+        if let Some(model) = patch.model {
+            job.model = Some(model);
+        }
+        if let Some(target) = patch.session_target {
+            job.session_target = target;
+        }
+        if let Some(delete_after_run) = patch.delete_after_run {
+            job.delete_after_run = delete_after_run;
+        }
+
+        if schedule_changed {
+            job.next_run = next_run_for_schedule(&job.schedule, Utc::now())?;
+        }
+
+        self.with_connection(|conn| {
+            conn.execute(
+                "UPDATE cron_jobs
+                 SET expression = ?1, command = ?2, schedule = ?3, job_type = ?4, prompt = ?5, name = ?6,
+                     session_target = ?7, model = ?8, enabled = ?9, delivery = ?10, delete_after_run = ?11,
+                     next_run = ?12
+                 WHERE id = ?13",
+                params![
+                    job.expression,
+                    job.command,
+                    serde_json::to_string(&job.schedule)?,
+                    job.job_type.as_str(),
+                    job.prompt,
+                    job.name,
+                    job.session_target.as_str(),
+                    job.model,
+                    if job.enabled { 1 } else { 0 },
+                    serde_json::to_string(&job.delivery)?,
+                    if job.delete_after_run { 1 } else { 0 },
+                    job.next_run.to_rfc3339(),
+                    job.id,
+                ],
+            )
+            .context("Failed to update cron job")?;
+            Ok(())
+        })?;
+
+        self.get_job(job_id)
+    }
+
+    /// Record the last run status
+    pub fn record_last_run(
+        &self,
+        job_id: &str,
+        finished_at: DateTime<Utc>,
+        success: bool,
+        output: &str,
+    ) -> Result<()> {
+        let status = if success { "ok" } else { "error" };
+        let bounded_output = truncate_cron_output(output);
+        self.with_connection(|conn| {
+            conn.execute(
+                "UPDATE cron_jobs
+                 SET last_run = ?1, last_status = ?2, last_output = ?3
+                 WHERE id = ?4",
+                params![finished_at.to_rfc3339(), status, bounded_output, job_id],
+            )
+            .context("Failed to update cron last run fields")?;
+            Ok(())
+        })
+    }
+
+    /// Reschedule a job after a run
+    pub fn reschedule_after_run(&self, job: &CronJob, success: bool, output: &str) -> Result<()> {
+        let now = Utc::now();
+        let next_run = next_run_for_schedule(&job.schedule, now)?;
+        let status = if success { "ok" } else { "error" };
+        let bounded_output = truncate_cron_output(output);
+
+        self.with_connection(|conn| {
+            conn.execute(
+                "UPDATE cron_jobs
+                 SET next_run = ?1, last_run = ?2, last_status = ?3, last_output = ?4
+                 WHERE id = ?5",
+                params![
+                    next_run.to_rfc3339(),
+                    now.to_rfc3339(),
+                    status,
+                    bounded_output,
+                    job.id
+                ],
+            )
+            .context("Failed to update cron job run state")?;
+            Ok(())
+        })
+    }
+
+    /// Record a job run in the history
+    pub fn record_run(
+        &self,
+        job_id: &str,
+        started_at: DateTime<Utc>,
+        finished_at: DateTime<Utc>,
+        status: &str,
+        output: Option<&str>,
+        duration_ms: i64,
+    ) -> Result<()> {
+        let bounded_output = output.map(truncate_cron_output);
+        let max_run_history = self.max_run_history;
+
+        self.with_connection(|conn| {
+            let tx = conn.unchecked_transaction()?;
+
+            tx.execute(
+                "INSERT INTO cron_runs (job_id, started_at, finished_at, status, output, duration_ms)
+                 VALUES (?1, ?2, ?3, ?4, ?5, ?6)",
+                params![
+                    job_id,
+                    started_at.to_rfc3339(),
+                    finished_at.to_rfc3339(),
+                    status,
+                    bounded_output.as_deref(),
+                    duration_ms,
+                ],
+            )
+            .context("Failed to insert cron run")?;
+
+            let keep = i64::from(max_run_history.max(1));
+            tx.execute(
+                "DELETE FROM cron_runs
+                 WHERE job_id = ?1
+                   AND id NOT IN (
+                     SELECT id FROM cron_runs
+                     WHERE job_id = ?1
+                     ORDER BY started_at DESC, id DESC
+                     LIMIT ?2
+                   )",
+                params![job_id, keep],
+            )
+            .context("Failed to prune cron run history")?;
+
+            tx.commit()
+                .context("Failed to commit cron run transaction")?;
+            Ok(())
+        })
+    }
+
+    /// List runs for a job
+    pub fn list_runs(&self, job_id: &str, limit: usize) -> Result<Vec<CronRun>> {
+        self.with_connection(|conn| {
+            let lim = i64::try_from(limit.max(1)).context("Run history limit overflow")?;
+            let mut stmt = conn.prepare(
+                "SELECT id, job_id, started_at, finished_at, status, output, duration_ms
+                 FROM cron_runs
+                 WHERE job_id = ?1
+                 ORDER BY started_at DESC, id DESC
+                 LIMIT ?2",
+            )?;
+
+            let rows = stmt.query_map(params![job_id, lim], |row| {
+                Ok(CronRun {
+                    id: row.get(0)?,
+                    job_id: row.get(1)?,
+                    started_at: parse_rfc3339(&row.get::<_, String>(2)?)
+                        .map_err(sql_conversion_error)?,
+                    finished_at: parse_rfc3339(&row.get::<_, String>(3)?)
+                        .map_err(sql_conversion_error)?,
+                    status: row.get(4)?,
+                    output: row.get(5)?,
+                    duration_ms: row.get(6)?,
+                })
+            })?;
+
+            let mut runs = Vec::new();
+            for row in rows {
+                runs.push(row?);
+            }
+            Ok(runs)
+        })
+    }
+
+    fn with_connection<T>(&self, f: impl FnOnce(&Connection) -> Result<T>) -> Result<T> {
+        let conn = Connection::open(&self.db_path)
+            .with_context(|| format!("Failed to open cron DB: {}", self.db_path.display()))?;
+
+        conn.execute_batch(
+            "PRAGMA foreign_keys = ON;
+             CREATE TABLE IF NOT EXISTS cron_jobs (
+                id               TEXT PRIMARY KEY,
+                expression       TEXT NOT NULL,
+                command          TEXT NOT NULL,
+                schedule         TEXT,
+                job_type         TEXT NOT NULL DEFAULT 'shell',
+                prompt           TEXT,
+                name             TEXT,
+                session_target   TEXT NOT NULL DEFAULT 'isolated',
+                model            TEXT,
+                enabled          INTEGER NOT NULL DEFAULT 1,
+                delivery         TEXT,
+                delete_after_run INTEGER NOT NULL DEFAULT 0,
+                created_at       TEXT NOT NULL,
+                next_run         TEXT NOT NULL,
+                last_run         TEXT,
+                last_status      TEXT,
+                last_output      TEXT
+            );
+            CREATE INDEX IF NOT EXISTS idx_cron_jobs_next_run ON cron_jobs(next_run);
+
+            CREATE TABLE IF NOT EXISTS cron_runs (
+                id          INTEGER PRIMARY KEY AUTOINCREMENT,
+                job_id      TEXT NOT NULL,
+                started_at  TEXT NOT NULL,
+                finished_at TEXT NOT NULL,
+                status      TEXT NOT NULL,
+                output      TEXT,
+                duration_ms INTEGER,
+                FOREIGN KEY (job_id) REFERENCES cron_jobs(id) ON DELETE CASCADE
+            );
+            CREATE INDEX IF NOT EXISTS idx_cron_runs_job_id ON cron_runs(job_id);
+            CREATE INDEX IF NOT EXISTS idx_cron_runs_started_at ON cron_runs(started_at);
+            CREATE INDEX IF NOT EXISTS idx_cron_runs_job_started ON cron_runs(job_id, started_at);",
+        )
+        .context("Failed to initialize cron schema")?;
+
+        f(&conn)
+    }
+}
+
+fn truncate_cron_output(output: &str) -> String {
+    if output.len() <= MAX_CRON_OUTPUT_BYTES {
+        return output.to_string();
+    }
+
+    if MAX_CRON_OUTPUT_BYTES <= TRUNCATED_OUTPUT_MARKER.len() {
+        return TRUNCATED_OUTPUT_MARKER.to_string();
+    }
+
+    let mut cutoff = MAX_CRON_OUTPUT_BYTES - TRUNCATED_OUTPUT_MARKER.len();
+    while cutoff > 0 && !output.is_char_boundary(cutoff) {
+        cutoff -= 1;
+    }
+
+    let mut truncated = output[..cutoff].to_string();
+    truncated.push_str(TRUNCATED_OUTPUT_MARKER);
+    truncated
+}
+
+fn parse_rfc3339(raw: &str) -> Result<DateTime<Utc>> {
+    let parsed = DateTime::parse_from_rfc3339(raw)
+        .with_context(|| format!("Invalid RFC3339 timestamp in cron DB: {raw}"))?;
+    Ok(parsed.with_timezone(&Utc))
+}
+
+fn sql_conversion_error(err: anyhow::Error) -> rusqlite::Error {
+    rusqlite::Error::ToSqlConversionFailure(err.into())
+}
+
+fn map_cron_job_row(row: &rusqlite::Row<'_>) -> rusqlite::Result<CronJob> {
+    let expression: String = row.get(1)?;
+    let schedule_raw: Option<String> = row.get(3)?;
+    let schedule = decode_schedule(schedule_raw.as_deref(), &expression).map_err(sql_conversion_error)?;
+
+    let delivery_raw: Option<String> = row.get(10)?;
+    let delivery = decode_delivery(delivery_raw.as_deref()).map_err(sql_conversion_error)?;
+
+    let next_run_raw: String = row.get(13)?;
+    let last_run_raw: Option<String> = row.get(14)?;
+    let created_at_raw: String = row.get(12)?;
+
+    Ok(CronJob {
+        id: row.get(0)?,
+        expression,
+        schedule,
+        command: row.get(2)?,
+        job_type: JobType::parse(&row.get::<_, String>(4)?),
+        prompt: row.get(5)?,
+        name: row.get(6)?,
+        session_target: SessionTarget::parse(&row.get::<_, String>(7)?),
+        model: row.get(8)?,
+        enabled: row.get::<_, i64>(9)? != 0,
+        delivery,
+        delete_after_run: row.get::<_, i64>(11)? != 0,
+        created_at: parse_rfc3339(&created_at_raw).map_err(sql_conversion_error)?,
+        next_run: parse_rfc3339(&next_run_raw).map_err(sql_conversion_error)?,
+        last_run: match last_run_raw {
+            Some(raw) => Some(parse_rfc3339(&raw).map_err(sql_conversion_error)?),
+            None => None,
+        },
+        last_status: row.get(15)?,
+        last_output: row.get(16)?,
+    })
+}
+
+fn decode_schedule(schedule_raw: Option<&str>, expression: &str) -> Result<Schedule> {
+    if let Some(raw) = schedule_raw {
+        let trimmed = raw.trim();
+        if !trimmed.is_empty() {
+            return serde_json::from_str(trimmed)
+                .with_context(|| format!("Failed to parse cron schedule JSON: {trimmed}"));
+        }
+    }
+
+    if expression.trim().is_empty() {
+        anyhow::bail!("Missing schedule and legacy expression for cron job")
+    }
+
+    Ok(Schedule::Cron {
+        expr: expression.to_string(),
+        tz: None,
+    })
+}
+
+fn decode_delivery(delivery_raw: Option<&str>) -> Result<DeliveryConfig> {
+    if let Some(raw) = delivery_raw {
+        let trimmed = raw.trim();
+        if !trimmed.is_empty() {
+            return serde_json::from_str(trimmed)
+                .with_context(|| format!("Failed to parse cron delivery JSON: {trimmed}"));
+        }
+    }
+    Ok(DeliveryConfig::default())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::TempDir;
+
+    fn test_store(tmp: &TempDir) -> CronStore {
+        CronStore::new(tmp.path(), 100, 10).unwrap()
+    }
+
+    #[test]
+    fn add_job_accepts_five_field_expression() {
+        let tmp = TempDir::new().unwrap();
+        let store = test_store(&tmp);
+
+        let job = store.add_job("*/5 * * * *", "echo ok").unwrap();
+        assert_eq!(job.expression, "*/5 * * * *");
+        assert_eq!(job.command, "echo ok");
+        assert!(matches!(job.schedule, Schedule::Cron { .. }));
+    }
+
+    #[test]
+    fn add_list_remove_roundtrip() {
+        let tmp = TempDir::new().unwrap();
+        let store = test_store(&tmp);
+
+        let job = store.add_job("*/10 * * * *", "echo roundtrip").unwrap();
+        let listed = store.list_jobs().unwrap();
+        assert_eq!(listed.len(), 1);
+        assert_eq!(listed[0].id, job.id);
+
+        store.remove_job(&job.id).unwrap();
+        assert!(store.list_jobs().unwrap().is_empty());
+    }
+}