config: add timezone (runner) and working_dir (per-job)

- runner.timezone: interpret cron schedules in specified timezone
- job.working_dir: run job in subdirectory of job snapshot

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

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

Author: aster-void

Cargo.lock

@@ -7,6 +7,7 @@ edition = "2024"
 tokio = { version = "1", features = ["full"] }
 cron = "0.15"
 chrono = "0.4"
+chrono-tz = "0.10"
 anyhow = "1"
 clap = { version = "4", features = ["derive"] }
 dirs = "6"

Cargo.toml

@@ -61,7 +61,6 @@ rollcron https://github.com/user/repo --pull-interval 300
 
 ```yaml
 runner:                       # Optional: global settings
-  working_dir: ./scripts      # Working directory (relative to job dir)
   timezone: Asia/Tokyo        # Timezone for cron schedules (default: UTC)
 
 jobs:
@@ -72,6 +71,7 @@ jobs:
     run: command              # Shell command
     timeout: 10s              # Optional (default: 10s)
     concurrency: skip         # Optional: parallel|wait|skip|replace (default: skip)
+    working_dir: ./subdir     # Optional: working directory (relative to job snapshot dir)
     retry:                    # Optional
       max: 3                  # Max retry attempts
       delay: 1s               # Initial delay (default: 1s), exponential backoff
@@ -83,7 +83,6 @@ Global settings that apply to all jobs:
 
 | Field | Description |
 |-------|-------------|
-| `working_dir` | Working directory for all jobs (relative to job snapshot dir) |
 | `timezone` | Timezone for cron schedule interpretation (e.g., `Asia/Tokyo`, `America/New_York`) |
 
 ### Concurrency
@@ -161,14 +160,16 @@ Options:
 ## Example: GitHub Actions-style Workflow
 
 ```yaml
+runner:
+  timezone: America/New_York
+
 jobs:
   test:
     name: "Run Tests"
     schedule:
       cron: "0 */6 * * *"
-    run: |
-      npm install
-      npm test
+    run: npm test
+    working_dir: ./frontend
     retry:
       max: 2
       delay: 30s

README.md

@@ -1,10 +1,21 @@
 use anyhow::{anyhow, Result};
+use chrono_tz::Tz;
 use cron::Schedule;
 use serde::Deserialize;
 use std::collections::HashMap;
 use std::str::FromStr;
 use std::time::Duration;
 
+#[derive(Debug, Clone, Default)]
+pub struct RunnerConfig {
+    pub timezone: Option<Tz>,
+}
+
+#[derive(Debug, Deserialize, Default)]
+struct RunnerConfigRaw {
+    timezone: Option<String>,
+}
+
 #[derive(Debug, Clone, Default, Deserialize, PartialEq)]
 #[serde(rename_all = "lowercase")]
 pub enum Concurrency {
@@ -16,8 +27,10 @@ pub enum Concurrency {
 }
 
 #[derive(Debug, Deserialize)]
-pub struct Config {
-    pub jobs: HashMap<String, JobConfig>,
+struct Config {
+    #[serde(default)]
+    runner: RunnerConfigRaw,
+    jobs: HashMap<String, JobConfig>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -30,6 +43,7 @@ pub struct JobConfig {
     #[serde(default)]
     pub concurrency: Concurrency,
     pub retry: Option<RetryConfigRaw>,
+    pub working_dir: Option<String>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -62,6 +76,7 @@ pub struct Job {
     pub timeout: Duration,
     pub concurrency: Concurrency,
     pub retry: Option<RetryConfig>,
+    pub working_dir: Option<String>,
 }
 
 #[derive(Debug, Clone)]
@@ -70,11 +85,20 @@ pub struct RetryConfig {
     pub delay: Duration,
 }
 
-pub fn parse_config(content: &str) -> Result<Vec<Job>> {
+pub fn parse_config(content: &str) -> Result<(RunnerConfig, Vec<Job>)> {
     let config: Config = serde_yaml::from_str(content)
         .map_err(|e| anyhow!("Failed to parse YAML: {}", e))?;
 
-    config
+    let timezone = config
+        .runner
+        .timezone
+        .map(|s| s.parse::<Tz>())
+        .transpose()
+        .map_err(|e| anyhow!("Invalid timezone: {}", e))?;
+
+    let runner = RunnerConfig { timezone };
+
+    let jobs = config
         .jobs
         .into_iter()
         .map(|(id, job)| {
@@ -104,9 +128,12 @@ pub fn parse_config(content: &str) -> Result<Vec<Job>> {
                 timeout,
                 concurrency: job.concurrency,
                 retry,
+                working_dir: job.working_dir,
             })
         })
-        .collect()
+        .collect::<Result<Vec<_>>>()?;
+
+    Ok((runner, jobs))
 }
 
 fn parse_duration(s: &str) -> Result<Duration> {
@@ -135,7 +162,7 @@ jobs:
       cron: "*/5 * * * *"
     run: echo hello
 "#;
-        let jobs = parse_config(yaml).unwrap();
+        let (_, jobs) = parse_config(yaml).unwrap();
         assert_eq!(jobs.len(), 1);
         assert_eq!(jobs[0].id, "hello");
         assert_eq!(jobs[0].name, "hello");
@@ -153,7 +180,7 @@ jobs:
       cron: "0 * * * *"
     run: cargo build
 "#;
-        let jobs = parse_config(yaml).unwrap();
+        let (_, jobs) = parse_config(yaml).unwrap();
         assert_eq!(jobs[0].id, "build");
         assert_eq!(jobs[0].name, "Build Project");
     }
@@ -168,7 +195,7 @@ jobs:
     run: sleep 30
     timeout: 60s
 "#;
-        let jobs = parse_config(yaml).unwrap();
+        let (_, jobs) = parse_config(yaml).unwrap();
         assert_eq!(jobs[0].timeout, Duration::from_secs(60));
     }
 
@@ -187,7 +214,7 @@ jobs:
     run: echo two
     timeout: 30s
 "#;
-        let jobs = parse_config(yaml).unwrap();
+        let (_, jobs) = parse_config(yaml).unwrap();
         assert_eq!(jobs.len(), 2);
     }
 
@@ -207,7 +234,7 @@ jobs:
       cron: "* * * * *"
     run: echo test
 "#;
-        let jobs = parse_config(yaml).unwrap();
+        let (_, jobs) = parse_config(yaml).unwrap();
         assert_eq!(jobs[0].concurrency, Concurrency::Skip);
     }
 
@@ -236,7 +263,7 @@ jobs:
     run: echo 4
     concurrency: replace
 "#;
-        let jobs = parse_config(yaml).unwrap();
+        let (_, jobs) = parse_config(yaml).unwrap();
         let find = |id: &str| jobs.iter().find(|j| j.id == id).unwrap();
 
         assert_eq!(find("parallel_job").concurrency, Concurrency::Parallel);
@@ -261,7 +288,7 @@ jobs:
       cron: "* * * * *"
     run: echo test
 "#;
-        let jobs = parse_config(yaml).unwrap();
+        let (_, jobs) = parse_config(yaml).unwrap();
         let find = |id: &str| jobs.iter().find(|j| j.id == id).unwrap();
 
         let retry = find("with_retry").retry.as_ref().unwrap();
@@ -282,9 +309,65 @@ jobs:
     retry:
       max: 2
 "#;
-        let jobs = parse_config(yaml).unwrap();
+        let (_, jobs) = parse_config(yaml).unwrap();
         let retry = jobs[0].retry.as_ref().unwrap();
         assert_eq!(retry.max, 2);
         assert_eq!(retry.delay, Duration::from_secs(1)); // default delay
     }
+
+    #[test]
+    fn parse_runner_config() {
+        let yaml = r#"
+runner:
+  timezone: Asia/Tokyo
+jobs:
+  test:
+    schedule:
+      cron: "* * * * *"
+    run: echo test
+"#;
+        let (runner, _) = parse_config(yaml).unwrap();
+        assert_eq!(runner.timezone, Some(chrono_tz::Asia::Tokyo));
+    }
+
+    #[test]
+    fn parse_runner_config_defaults() {
+        let yaml = r#"
+jobs:
+  test:
+    schedule:
+      cron: "* * * * *"
+    run: echo test
+"#;
+        let (runner, _) = parse_config(yaml).unwrap();
+        assert!(runner.timezone.is_none());
+    }
+
+    #[test]
+    fn parse_working_dir() {
+        let yaml = r#"
+jobs:
+  test:
+    schedule:
+      cron: "* * * * *"
+    run: echo test
+    working_dir: ./scripts
+"#;
+        let (_, jobs) = parse_config(yaml).unwrap();
+        assert_eq!(jobs[0].working_dir.as_deref(), Some("./scripts"));
+    }
+
+    #[test]
+    fn parse_invalid_timezone() {
+        let yaml = r#"
+runner:
+  timezone: Invalid/Zone
+jobs:
+  test:
+    schedule:
+      cron: "* * * * *"
+    run: echo test
+"#;
+        assert!(parse_config(yaml).is_err());
+    }
 }

src/config.rs

@@ -43,10 +43,10 @@ async fn main() -> Result<()> {
     let sot_path = git::ensure_repo(&source)?;
     println!("[rollcron] Cache: {}", sot_path.display());
 
-    let initial_jobs = load_config(&sot_path)?;
+    let (initial_runner, initial_jobs) = load_config(&sot_path)?;
     sync_job_dirs(&sot_path, &initial_jobs)?;
 
-    let (tx, mut rx) = tokio::sync::watch::channel(initial_jobs);
+    let (tx, mut rx) = tokio::sync::watch::channel((initial_runner, initial_jobs));
 
     // Spawn auto-sync task
     let source_clone = source.clone();
@@ -66,12 +66,12 @@ async fn main() -> Result<()> {
             println!("[rollcron] Synced from upstream");
 
             match load_config(&sot) {
-                Ok(jobs) => {
+                Ok((runner, jobs)) => {
                     if let Err(e) = sync_job_dirs(&sot, &jobs) {
                         eprintln!("[rollcron] Failed to sync job dirs: {}", e);
                         continue;
                     }
-                    let _ = tx.send(jobs);
+                    let _ = tx.send((runner, jobs));
                     println!("[rollcron] Synced job directories");
                 }
                 Err(e) => eprintln!("[rollcron] Failed to reload config: {}", e),
@@ -81,18 +81,18 @@ async fn main() -> Result<()> {
 
     // Main scheduler loop
     loop {
-        let jobs = rx.borrow_and_update().clone();
+        let (runner, jobs) = rx.borrow_and_update().clone();
         let sot = sot_path.clone();
         tokio::select! {
-            _ = scheduler::run_scheduler(jobs, sot) => {}
+            _ = scheduler::run_scheduler(jobs, sot, runner) => {}
             _ = rx.changed() => {
                 println!("[rollcron] Config updated, restarting scheduler");
             }
         }
     }
 }
 
-fn load_config(sot_path: &PathBuf) -> Result<Vec<config::Job>> {
+fn load_config(sot_path: &PathBuf) -> Result<(config::RunnerConfig, Vec<config::Job>)> {
     let config_path = sot_path.join(CONFIG_FILE);
     let content = std::fs::read_to_string(&config_path)
         .map_err(|e| anyhow::anyhow!("Failed to read {}: {}", config_path.display(), e))?;