treewide: add per-job timezone, enabled flag, and .env loading

- Per-job timezone: jobs can override runner timezone with their own
  timezone setting (e.g., timezone: America/New_York)
- Enabled flag: jobs can be disabled with enabled: false
- .env loading: automatically load .env file from job working directory
- Security: add path traversal protection for working_dir
- Fix unwrap in retry backoff calculation

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: aster-void

src/config.rs

@@ -69,6 +69,8 @@ pub struct JobConfig {
     pub retry: Option<RetryConfigRaw>,
     pub working_dir: Option<String>,
     pub jitter: Option<String>,
+    pub enabled: Option<bool>,
+    pub timezone: Option<String>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -104,6 +106,8 @@ pub struct Job {
     pub retry: Option<RetryConfig>,
     pub working_dir: Option<String>,
     pub jitter: Option<Duration>,
+    pub enabled: bool,
+    pub timezone: Option<TimezoneConfig>,
 }
 
 #[derive(Debug, Clone)]
@@ -168,6 +172,19 @@ pub fn parse_config(content: &str) -> Result<(RunnerConfig, Vec<Job>)> {
                     .map_err(|e| anyhow!("Invalid jitter '{}' in job '{}': {}", j, id, e)))
                 .transpose()?;
 
+            let job_timezone = job
+                .timezone
+                .map(|tz| {
+                    if tz == "inherit" {
+                        Ok(TimezoneConfig::Inherit)
+                    } else {
+                        tz.parse::<Tz>()
+                            .map(TimezoneConfig::Named)
+                            .map_err(|e| anyhow!("Invalid timezone '{}' in job '{}': {}", tz, id, e))
+                    }
+                })
+                .transpose()?;
+
             Ok(Job {
                 id,
                 name,
@@ -178,6 +195,8 @@ pub fn parse_config(content: &str) -> Result<(RunnerConfig, Vec<Job>)> {
                 retry,
                 working_dir: job.working_dir,
                 jitter,
+                enabled: job.enabled.unwrap_or(true),
+                timezone: job_timezone,
             })
         })
         .collect::<Result<Vec<_>>>()?;
@@ -541,6 +560,100 @@ jobs:
     run: echo test
     retry:
       max: 0
+"#;
+        assert!(parse_config(yaml).is_err());
+    }
+
+    #[test]
+    fn parse_enabled_false() {
+        let yaml = r#"
+jobs:
+  test_disabled:
+    schedule:
+      cron: "* * * * *"
+    run: echo test
+    enabled: false
+"#;
+        let (_, jobs) = parse_config(yaml).unwrap();
+        assert_eq!(jobs[0].enabled, false);
+    }
+
+    #[test]
+    fn parse_enabled_true() {
+        let yaml = r#"
+jobs:
+  test_enabled:
+    schedule:
+      cron: "* * * * *"
+    run: echo test
+    enabled: true
+"#;
+        let (_, jobs) = parse_config(yaml).unwrap();
+        assert_eq!(jobs[0].enabled, true);
+    }
+
+    #[test]
+    fn parse_enabled_default() {
+        let yaml = r#"
+jobs:
+  test_default:
+    schedule:
+      cron: "* * * * *"
+    run: echo test
+"#;
+        let (_, jobs) = parse_config(yaml).unwrap();
+        assert_eq!(jobs[0].enabled, true);
+    }
+
+    #[test]
+    fn parse_job_with_timezone() {
+        let yaml = r#"
+runner:
+  timezone: Asia/Tokyo
+jobs:
+  job1:
+    schedule:
+      cron: "* * * * *"
+    run: echo test
+    timezone: America/New_York
+  job2:
+    schedule:
+      cron: "* * * * *"
+    run: echo test
+"#;
+        let (runner, jobs) = parse_config(yaml).unwrap();
+        assert_eq!(runner.timezone, TimezoneConfig::Named(chrono_tz::Asia::Tokyo));
+        let find = |id: &str| jobs.iter().find(|j| j.id == id).unwrap();
+        assert_eq!(
+            find("job1").timezone,
+            Some(TimezoneConfig::Named(chrono_tz::America::New_York))
+        );
+        assert!(find("job2").timezone.is_none());
+    }
+
+    #[test]
+    fn parse_job_timezone_inherit() {
+        let yaml = r#"
+jobs:
+  test:
+    schedule:
+      cron: "* * * * *"
+    run: echo test
+    timezone: inherit
+"#;
+        let (_, jobs) = parse_config(yaml).unwrap();
+        assert_eq!(jobs[0].timezone, Some(TimezoneConfig::Inherit));
+    }
+
+    #[test]
+    fn parse_invalid_job_timezone() {
+        let yaml = r#"
+jobs:
+  test:
+    schedule:
+      cron: "* * * * *"
+    run: echo test
+    timezone: Invalid/Zone
 "#;
         assert!(parse_config(yaml).is_err());
     }

src/env.rs

@@ -0,0 +1,115 @@
+use anyhow::Result;
+use std::collections::HashMap;
+use std::path::Path;
+
+/// Load environment variables from .env file if it exists.
+/// Returns a HashMap of key-value pairs.
+/// If the .env file doesn't exist, returns an empty HashMap (no error).
+pub fn load_env_file(dir: &Path) -> Result<HashMap<String, String>> {
+    let env_path = dir.join(".env");
+
+    if !env_path.exists() {
+        return Ok(HashMap::new());
+    }
+
+    let content = std::fs::read_to_string(&env_path)?;
+    let mut vars = HashMap::new();
+
+    for line in content.lines() {
+        let line = line.trim();
+
+        // Skip empty lines and comments
+        if line.is_empty() || line.starts_with('#') {
+            continue;
+        }
+
+        // Parse KEY=VALUE
+        if let Some((key, value)) = line.split_once('=') {
+            let key = key.trim().to_string();
+            let value = value.trim().to_string();
+
+            // Remove quotes from value if present
+            let value = if (value.starts_with('"') && value.ends_with('"'))
+                || (value.starts_with('\'') && value.ends_with('\''))
+            {
+                value[1..value.len() - 1].to_string()
+            } else {
+                value
+            };
+
+            vars.insert(key, value);
+        }
+    }
+
+    Ok(vars)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+    use tempfile::TempDir;
+
+    #[test]
+    fn test_load_env_file_exists() {
+        let dir = TempDir::new().unwrap();
+        let env_path = dir.path().join(".env");
+        fs::write(&env_path, "FOO=bar\nBAZ=qux").unwrap();
+
+        let vars = load_env_file(dir.path()).unwrap();
+        assert_eq!(vars.get("FOO"), Some(&"bar".to_string()));
+        assert_eq!(vars.get("BAZ"), Some(&"qux".to_string()));
+    }
+
+    #[test]
+    fn test_load_env_file_missing() {
+        let dir = TempDir::new().unwrap();
+        let vars = load_env_file(dir.path()).unwrap();
+        assert!(vars.is_empty());
+    }
+
+    #[test]
+    fn test_load_env_with_quotes() {
+        let dir = TempDir::new().unwrap();
+        let env_path = dir.path().join(".env");
+        fs::write(&env_path, "QUOTED=\"hello world\"\nSINGLE='test'").unwrap();
+
+        let vars = load_env_file(dir.path()).unwrap();
+        assert_eq!(vars.get("QUOTED"), Some(&"hello world".to_string()));
+        assert_eq!(vars.get("SINGLE"), Some(&"test".to_string()));
+    }
+
+    #[test]
+    fn test_load_env_with_comments() {
+        let dir = TempDir::new().unwrap();
+        let env_path = dir.path().join(".env");
+        fs::write(&env_path, "# Comment\nKEY=value\n# Another comment\nFOO=bar").unwrap();
+
+        let vars = load_env_file(dir.path()).unwrap();
+        assert_eq!(vars.len(), 2);
+        assert_eq!(vars.get("KEY"), Some(&"value".to_string()));
+        assert_eq!(vars.get("FOO"), Some(&"bar".to_string()));
+    }
+
+    #[test]
+    fn test_load_env_with_empty_lines() {
+        let dir = TempDir::new().unwrap();
+        let env_path = dir.path().join(".env");
+        fs::write(&env_path, "KEY1=value1\n\nKEY2=value2\n\n").unwrap();
+
+        let vars = load_env_file(dir.path()).unwrap();
+        assert_eq!(vars.len(), 2);
+        assert_eq!(vars.get("KEY1"), Some(&"value1".to_string()));
+        assert_eq!(vars.get("KEY2"), Some(&"value2".to_string()));
+    }
+
+    #[test]
+    fn test_load_env_with_spaces() {
+        let dir = TempDir::new().unwrap();
+        let env_path = dir.path().join(".env");
+        fs::write(&env_path, "KEY = value with spaces").unwrap();
+
+        let vars = load_env_file(dir.path()).unwrap();
+        assert_eq!(vars.get("KEY"), Some(&"value with spaces".to_string()));
+    }
+}

src/main.rs

@@ -1,4 +1,5 @@
 mod config;
+mod env;
 mod git;
 mod scheduler;
 

src/scheduler/executor.rs

@@ -4,14 +4,28 @@ use tokio::process::Command;
 use tokio::time::sleep;
 
 use crate::config::Job;
+use crate::env;
 use crate::git;
 
 use super::backoff::{calculate_backoff, generate_jitter};
 
 pub fn resolve_work_dir(sot_path: &PathBuf, job_id: &str, working_dir: &Option<String>) -> PathBuf {
     let job_dir = git::get_job_dir(sot_path, job_id);
     match working_dir {
-        Some(dir) => job_dir.join(dir),
+        Some(dir) => {
+            let work_path = job_dir.join(dir);
+            // Canonicalize to resolve .. and symlinks, then verify path is within job_dir
+            match (work_path.canonicalize(), job_dir.canonicalize()) {
+                (Ok(resolved), Ok(base)) if resolved.starts_with(&base) => resolved,
+                _ => {
+                    eprintln!(
+                        "[job:{}] Invalid working_dir '{}': path traversal or non-existent",
+                        job_id, dir
+                    );
+                    job_dir
+                }
+            }
+        }
         None => job_dir,
     }
 }
@@ -32,9 +46,11 @@ pub async fn execute_job(job: &Job, work_dir: &PathBuf) {
 
     for attempt in 0..max_attempts {
         if attempt > 0 {
-            let delay = calculate_backoff(job.retry.as_ref().unwrap(), attempt - 1);
-            println!("{} Retry {}/{} after {:?}", tag, attempt, max_attempts - 1, delay);
-            sleep(delay).await;
+            if let Some(retry) = job.retry.as_ref() {
+                let delay = calculate_backoff(retry, attempt - 1);
+                println!("{} Retry {}/{} after {:?}", tag, attempt, max_attempts - 1, delay);
+                sleep(delay).await;
+            }
         }
 
         println!("{} Starting '{}'", tag, job.name);
@@ -54,14 +70,27 @@ pub async fn execute_job(job: &Job, work_dir: &PathBuf) {
 }
 
 async fn run_command(job: &Job, work_dir: &PathBuf) -> CommandResult {
-    let child = match Command::new("sh")
-        .args(["-c", &job.command])
+    // Load .env file if it exists
+    let env_vars = match env::load_env_file(work_dir) {
+        Ok(vars) => vars,
+        Err(e) => {
+            return CommandResult::ExecError(format!("Failed to load .env file: {}", e));
+        }
+    };
+
+    let mut cmd = Command::new("sh");
+    cmd.args(["-c", &job.command])
         .current_dir(work_dir)
         .stdout(std::process::Stdio::piped())
         .stderr(std::process::Stdio::piped())
-        .kill_on_drop(true)
-        .spawn()
-    {
+        .kill_on_drop(true);
+
+    // Apply environment variables from .env file
+    for (key, value) in env_vars {
+        cmd.env(key, value);
+    }
+
+    let child = match cmd.spawn() {
         Ok(c) => c,
         Err(e) => return CommandResult::ExecError(e.to_string()),
     };
@@ -141,6 +170,8 @@ mod tests {
             retry: None,
             working_dir: None,
             jitter: None,
+            enabled: true,
+            timezone: None,
         }
     }
 
@@ -195,4 +226,22 @@ mod tests {
         execute_job(&job, &dir.path().to_path_buf()).await;
         assert!(start.elapsed() < Duration::from_secs(1));
     }
+
+    #[tokio::test]
+    async fn job_with_env_file() {
+        let dir = tempdir().unwrap();
+        let env_path = dir.path().join(".env");
+        std::fs::write(&env_path, "TEST_VAR=hello\nOTHER_VAR=world").unwrap();
+
+        let job = make_job("echo $TEST_VAR $OTHER_VAR", 10);
+        execute_job(&job, &dir.path().to_path_buf()).await;
+    }
+
+    #[tokio::test]
+    async fn job_without_env_file() {
+        let dir = tempdir().unwrap();
+        // No .env file created - should work fine
+        let job = make_job("echo no env file", 10);
+        execute_job(&job, &dir.path().to_path_buf()).await;
+    }
 }