Scheduler cleanup

crates/goose-cli/src/commands/schedule.rs

@@ -1,21 +1,10 @@
 use anyhow::{bail, Context, Result};
-use base64::engine::{general_purpose::STANDARD as BASE64_STANDARD, Engine};
 use goose::scheduler::{
-    get_default_scheduled_recipes_dir, get_default_scheduler_storage_path, ScheduledJob,
+    get_default_scheduled_recipes_dir, get_default_scheduler_storage_path, ScheduledJob, Scheduler,
     SchedulerError,
 };
-use goose::scheduler_factory::SchedulerFactory;
 use std::path::Path;
 
-// Base64 decoding function - might be needed if recipe_source_arg can be base64
-// For now, handle_schedule_add will assume it's a path.
-async fn _decode_base64_recipe(source: &str) -> Result<String> {
-    let bytes = BASE64_STANDARD
-        .decode(source.as_bytes())
-        .with_context(|| "Recipe source is not a valid path and not valid Base64.")?;
-    String::from_utf8(bytes).with_context(|| "Decoded Base64 recipe source is not valid UTF-8.")
-}
-
 fn validate_cron_expression(cron: &str) -> Result<()> {
     // Basic validation and helpful suggestions
     if cron.trim().is_empty() {
@@ -84,7 +73,6 @@ pub async fn handle_schedule_add(
         schedule_id, cron, recipe_source_arg
     );
 
-    // Validate cron expression and provide helpful feedback
     validate_cron_expression(&cron)?;
 
     // The Scheduler's add_scheduled_job will handle copying the recipe from recipe_source_arg
@@ -102,7 +90,7 @@ pub async fn handle_schedule_add(
 
     let scheduler_storage_path =
         get_default_scheduler_storage_path().context("Failed to get scheduler storage path")?;
-    let scheduler = SchedulerFactory::create(scheduler_storage_path)
+    let scheduler = Scheduler::new(scheduler_storage_path)
         .await
         .context("Failed to initialize scheduler")?;
 
@@ -148,11 +136,11 @@ pub async fn handle_schedule_add(
 pub async fn handle_schedule_list() -> Result<()> {
     let scheduler_storage_path =
         get_default_scheduler_storage_path().context("Failed to get scheduler storage path")?;
-    let scheduler = SchedulerFactory::create(scheduler_storage_path)
+    let scheduler = Scheduler::new(scheduler_storage_path)
         .await
         .context("Failed to initialize scheduler")?;
 
-    let jobs = scheduler.list_scheduled_jobs().await?;
+    let jobs = scheduler.list_scheduled_jobs().await;
     if jobs.is_empty() {
         println!("No scheduled jobs found.");
     } else {
@@ -183,7 +171,7 @@ pub async fn handle_schedule_list() -> Result<()> {
 pub async fn handle_schedule_remove(schedule_id: String) -> Result<()> {
     let scheduler_storage_path =
         get_default_scheduler_storage_path().context("Failed to get scheduler storage path")?;
-    let scheduler = SchedulerFactory::create(scheduler_storage_path)
+    let scheduler = Scheduler::new(scheduler_storage_path)
         .await
         .context("Failed to initialize scheduler")?;
 
@@ -210,7 +198,7 @@ pub async fn handle_schedule_remove(schedule_id: String) -> Result<()> {
 pub async fn handle_schedule_sessions(schedule_id: String, limit: Option<usize>) -> Result<()> {
     let scheduler_storage_path =
         get_default_scheduler_storage_path().context("Failed to get scheduler storage path")?;
-    let scheduler = SchedulerFactory::create(scheduler_storage_path)
+    let scheduler = Scheduler::new(scheduler_storage_path)
         .await
         .context("Failed to initialize scheduler")?;
 
@@ -246,7 +234,7 @@ pub async fn handle_schedule_sessions(schedule_id: String, limit: Option<usize>)
 pub async fn handle_schedule_run_now(schedule_id: String) -> Result<()> {
     let scheduler_storage_path =
         get_default_scheduler_storage_path().context("Failed to get scheduler storage path")?;
-    let scheduler = SchedulerFactory::create(scheduler_storage_path)
+    let scheduler = Scheduler::new(scheduler_storage_path)
         .await
         .context("Failed to initialize scheduler")?;
 

crates/goose-server/src/routes/schedule.rs

@@ -16,8 +16,6 @@ pub struct CreateScheduleRequest {
     id: String,
     recipe_source: String,
     cron: String,
-    #[serde(default)]
-    execution_mode: Option<String>, // "foreground" or "background"
 }
 
 #[derive(Deserialize, Serialize, utoipa::ToSchema)]
@@ -36,7 +34,6 @@ pub struct KillJobResponse {
     message: String,
 }
 
-// Response for the inspect endpoint
 #[derive(Serialize, utoipa::ToSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct InspectJobResponse {
@@ -51,15 +48,9 @@ pub struct RunNowResponse {
     session_id: String,
 }
 
-// Query parameters for the sessions endpoint
 #[derive(Deserialize, utoipa::ToSchema, utoipa::IntoParams)]
 pub struct SessionsQuery {
-    #[serde(default = "default_limit")]
-    limit: u32,
-}
-
-fn default_limit() -> u32 {
-    50 // Default limit for sessions listed
+    limit: usize,
 }
 
 // Struct for the frontend session list
@@ -151,10 +142,7 @@ async fn list_schedules(
         .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
 
     tracing::info!("Server: Calling scheduler.list_scheduled_jobs()");
-    let jobs = scheduler.list_scheduled_jobs().await.map_err(|e| {
-        eprintln!("Error listing schedules: {:?}", e);
-        StatusCode::INTERNAL_SERVER_ERROR
-    })?;
+    let jobs = scheduler.list_scheduled_jobs().await;
     Ok(Json(ListSchedulesResponse { jobs }))
 }
 
@@ -213,39 +201,40 @@ async fn run_now_handler(
         .await
         .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
 
-    let (recipe_display_name, recipe_version_opt) = match scheduler.list_scheduled_jobs().await {
-        Ok(jobs) => {
-            if let Some(job) = jobs.into_iter().find(|job| job.id == id) {
-                let recipe_display_name = std::path::Path::new(&job.source)
-                    .file_name()
-                    .and_then(|name| name.to_str())
-                    .map(|s| s.to_string())
-                    .unwrap_or_else(|| id.clone());
-
-                let recipe_version_opt = tokio::fs::read_to_string(&job.source)
-                    .await
+    let (recipe_display_name, recipe_version_opt) = if let Some(job) = scheduler
+        .list_scheduled_jobs()
+        .await
+        .into_iter()
+        .find(|job| job.id == id)
+    {
+        let recipe_display_name = std::path::Path::new(&job.source)
+            .file_name()
+            .and_then(|name| name.to_str())
+            .map(|s| s.to_string())
+            .unwrap_or_else(|| id.clone());
+
+        let recipe_version_opt =
+            tokio::fs::read_to_string(&job.source)
+                .await
+                .ok()
+                .and_then(|content: String| {
+                    goose::recipe::template_recipe::parse_recipe_content(
+                        &content,
+                        Some(
+                            std::path::Path::new(&job.source)
+                                .parent()
+                                .unwrap_or_else(|| std::path::Path::new(""))
+                                .to_string_lossy()
+                                .to_string(),
+                        ),
+                    )
                     .ok()
-                    .and_then(|content| {
-                        goose::recipe::template_recipe::parse_recipe_content(
-                            &content,
-                            Some(
-                                std::path::Path::new(&job.source)
-                                    .parent()
-                                    .unwrap_or_else(|| std::path::Path::new(""))
-                                    .to_string_lossy()
-                                    .to_string(),
-                            ),
-                        )
-                        .ok()
-                        .map(|(r, _)| r.version)
-                    });
-
-                (recipe_display_name, recipe_version_opt)
-            } else {
-                (id.clone(), None)
-            }
-        }
-        Err(_) => (id.clone(), None),
+                    .map(|(r, _)| r.version)
+                });
+
+        (recipe_display_name, recipe_version_opt)
+    } else {
+        (id.clone(), None)
     };
 
     let recipe_version_tag = recipe_version_opt.as_deref().unwrap_or("");
@@ -308,7 +297,7 @@ async fn sessions_handler(
         .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
 
     match scheduler
-        .sessions(&schedule_id_param, query_params.limit as usize)
+        .sessions(&schedule_id_param, query_params.limit)
         .await
     {
         Ok(session_tuples) => {
@@ -448,11 +437,7 @@ async fn update_schedule(
             }
         })?;
 
-    // Return the updated schedule
-    let jobs = scheduler.list_scheduled_jobs().await.map_err(|e| {
-        eprintln!("Error listing schedules after update: {:?}", e);
-        StatusCode::INTERNAL_SERVER_ERROR
-    })?;
+    let jobs = scheduler.list_scheduled_jobs().await;
     let updated_job = jobs
         .into_iter()
         .find(|job| job.id == id)

crates/goose/src/agents/agent.rs

@@ -39,7 +39,6 @@ use crate::permission::PermissionConfirmation;
 use crate::providers::base::Provider;
 use crate::providers::errors::ProviderError;
 use crate::recipe::{Author, Recipe, Response, Settings, SubRecipe};
-use crate::scheduler_trait::SchedulerTrait;
 use crate::security::security_inspector::SecurityInspector;
 use crate::tool_inspection::ToolInspectionManager;
 use crate::tool_monitor::RepetitionInspector;
@@ -60,6 +59,7 @@ use super::platform_tools;
 use super::tool_execution::{ToolCallResult, CHAT_MODE_TOOL_SKIPPED_RESPONSE, DECLINED_RESPONSE};
 use crate::agents::subagent_task_config::TaskConfig;
 use crate::conversation::message::{Message, MessageContent, SystemNotificationType, ToolRequest};
+use crate::scheduler_trait::SchedulerTrait;
 use crate::session::extension_data::{EnabledExtensionsState, ExtensionState};
 use crate::session::{Session, SessionManager};
 
@@ -346,7 +346,6 @@ impl Agent {
         Ok(tool_futures)
     }
 
-    /// Set the scheduler service for this agent
     pub async fn set_scheduler(&self, scheduler: Arc<dyn SchedulerTrait>) {
         let mut scheduler_service = self.scheduler_service.lock().await;
         *scheduler_service = Some(scheduler);

crates/goose/src/agents/schedule_tool.rs

@@ -9,11 +9,10 @@ use crate::mcp_utils::ToolResult;
 use chrono::Utc;
 use rmcp::model::{Content, ErrorCode, ErrorData};
 
+use super::Agent;
 use crate::recipe::Recipe;
 use crate::scheduler_trait::SchedulerTrait;
 
-use super::Agent;
-
 impl Agent {
     /// Handle schedule management tool calls
     pub async fn handle_schedule_management(
@@ -62,34 +61,24 @@ impl Agent {
         }
     }
 
-    /// List all scheduled jobs
     async fn handle_list_jobs(
         &self,
         scheduler: Arc<dyn SchedulerTrait>,
     ) -> ToolResult<Vec<Content>> {
-        match scheduler.list_scheduled_jobs().await {
-            Ok(jobs) => {
-                let jobs_json = serde_json::to_string_pretty(&jobs).map_err(|e| {
-                    ErrorData::new(
-                        ErrorCode::INTERNAL_ERROR,
-                        format!("Failed to serialize jobs: {}", e),
-                        None,
-                    )
-                })?;
-                Ok(vec![Content::text(format!(
-                    "Scheduled Jobs:\n{}",
-                    jobs_json
-                ))])
-            }
-            Err(e) => Err(ErrorData::new(
+        let jobs = scheduler.list_scheduled_jobs().await;
+        let jobs_json = serde_json::to_string_pretty(&jobs).map_err(|e| {
+            ErrorData::new(
                 ErrorCode::INTERNAL_ERROR,
-                format!("Failed to list jobs: {}", e),
+                format!("Failed to serialize jobs: {}", e),
                 None,
-            )),
-        }
+            )
+        })?;
+        Ok(vec![Content::text(format!(
+            "Scheduled Jobs:\n{}",
+            jobs_json
+        ))])
     }
 
-    /// Create a new scheduled job from a recipe file
     async fn handle_create_job(
         &self,
         scheduler: Arc<dyn SchedulerTrait>,
@@ -123,19 +112,6 @@ impl Agent {
             .and_then(|v| v.as_str())
             .unwrap_or("background");
 
-        // Validate execution_mode is either "foreground" or "background"
-        if execution_mode != "foreground" && execution_mode != "background" {
-            return Err(ErrorData::new(
-                ErrorCode::INTERNAL_ERROR,
-                format!(
-                    "Invalid execution_mode: {}. Must be 'foreground' or 'background'",
-                    execution_mode
-                ),
-                None,
-            ));
-        }
-
-        // Validate recipe file exists and is readable
         if !std::path::Path::new(recipe_path).exists() {
             return Err(ErrorData::new(
                 ErrorCode::INTERNAL_ERROR,

crates/goose/src/execution/manager.rs

@@ -1,7 +1,7 @@
 use crate::agents::extension::PlatformExtensionContext;
 use crate::agents::Agent;
 use crate::config::paths::Paths;
-use crate::scheduler_factory::SchedulerFactory;
+use crate::scheduler::Scheduler;
 use crate::scheduler_trait::SchedulerTrait;
 use anyhow::Result;
 use lru::LruCache;
@@ -35,7 +35,7 @@ impl AgentManager {
     async fn new(max_sessions: Option<usize>) -> Result<Self> {
         let schedule_file_path = Paths::data_dir().join("schedule.json");
 
-        let scheduler = SchedulerFactory::create(schedule_file_path).await?;
+        let scheduler = Scheduler::new(schedule_file_path).await?;
 
         let capacity = NonZeroUsize::new(max_sessions.unwrap_or(DEFAULT_MAX_SESSION))
             .unwrap_or_else(|| NonZeroUsize::new(100).unwrap());