refactor(cache): use random suffix and cleanup on exit

- Replace deterministic hash with random suffix for cache directories
- Add cleanup_cache_dir() to remove sot_path and job dirs on exit
- Remove unused `source` field from RunnerActor
- git_poll now receives sot_path directly instead of source URL

Author: aster-void

CLAUDE.md

@@ -107,11 +107,13 @@ jobs:
 
 ```
 ~/.cache/rollcron/
-├── <repo>-<hash>/              # SoT: git repository
-└── <repo>-<hash>@<job-id>/     # Per-job snapshot (no .git)
+├── <repo>-<random>/              # SoT: git repository (random suffix per run)
+└── <repo>-<random>@<job-id>/     # Per-job snapshot (no .git)
 ```
 
-**Important**: Directory names use `job.id` (the YAML key), not `job.name`.
+**Important**:
+- Directory names use `job.id` (the YAML key), not `job.name`
+- Each run creates new directories with a random suffix (cleaned up on exit)
 
 ## Assumptions
 
@@ -143,6 +145,11 @@ jobs:
 4. Apply task jitter (random delay 0 to jitter) before first execution
 5. On failure: apply exponential backoff + retry jitter before retry
 
+### Shutdown (Ctrl+C)
+1. Wait for running jobs to complete (graceful stop)
+2. Stop all job actors
+3. Remove all cache directories (sot_path + job dirs)
+
 ## Logging
 
 When `log_file` is set, command stdout/stderr is appended to the specified file. If not set, output is discarded.

src/actor/runner/git_poll.rs

@@ -11,7 +11,7 @@ use xtra::refcount::Weak;
 
 const CONFIG_FILE: &str = "rollcron.yaml";
 
-pub async fn run<A>(source: String, pull_interval: Duration, addr: Address<A, Weak>)
+pub async fn run<A>(sot_path: PathBuf, pull_interval: Duration, addr: Address<A, Weak>)
 where
     A: Handler<ConfigUpdate> + Handler<GetRunnerConfig, Return = RunnerConfig>,
 {
@@ -20,7 +20,7 @@ where
     loop {
         ticker.tick().await;
 
-        let (sot_path, update_info) = match git::ensure_repo(&source) {
+        let update_info = match git::sync_repo(&sot_path) {
             Ok(r) => r,
             Err(e) => {
                 error!(target: "rollcron::runner", error = %e, "Git sync failed");
@@ -38,7 +38,7 @@ where
             Ok((runner, jobs)) => {
                 if let Err(e) = addr
                     .send(ConfigUpdate {
-                        sot_path,
+                        sot_path: sot_path.clone(),
                         runner,
                         jobs,
                     })

src/actor/runner/mod.rs

@@ -16,7 +16,6 @@ const CONFIG_FILE: &str = "rollcron.yaml";
 
 /// Runner Actor - manages the lifecycle of all job actors
 pub struct RunnerActor {
-    source: String,
     pull_interval: Duration,
     sot_path: PathBuf,
     runner_config: RunnerConfig,
@@ -28,13 +27,11 @@ pub struct RunnerActor {
 
 impl RunnerActor {
     pub fn new(
-        source: String,
         pull_interval: Duration,
         sot_path: PathBuf,
         runner_config: RunnerConfig,
     ) -> Self {
         Self {
-            source,
             pull_interval,
             sot_path,
             runner_config,
@@ -67,11 +64,11 @@ impl Actor for RunnerActor {
         self.self_addr = Some(addr.clone());
 
         // Start git poll loop
-        let source = self.source.clone();
+        let sot_path = self.sot_path.clone();
         let pull_interval = self.pull_interval;
         let poll_addr = addr.clone();
         self.poll_handle = Some(tokio::spawn(async move {
-            git_poll::run(source, pull_interval, poll_addr).await;
+            git_poll::run(sot_path, pull_interval, poll_addr).await;
         }));
 
         // Start supervisor loop
@@ -245,6 +242,17 @@ impl Handler<RespawnJob> for RunnerActor {
     }
 }
 
+/// Get all job IDs for cleanup
+pub struct GetJobIds;
+
+impl Handler<GetJobIds> for RunnerActor {
+    type Return = Vec<String>;
+
+    async fn handle(&mut self, _msg: GetJobIds, _ctx: &mut Context<Self>) -> Self::Return {
+        self.job_actors.keys().cloned().collect()
+    }
+}
+
 /// Graceful shutdown
 pub struct GracefulShutdown;
 

src/git.rs

@@ -26,21 +26,29 @@ impl Drop for TempDirGuard<'_> {
     }
 }
 
-/// Ensures repo is cloned/synced to cache. Returns (cache path, commit_range if updated).
-pub fn ensure_repo(source: &str) -> Result<(PathBuf, Option<String>)> {
-    let cache_dir = get_cache_dir(source)?;
+/// Generates a cache directory path with random suffix.
+pub fn generate_cache_path(source: &str) -> PathBuf {
+    let cache_base = dirs::cache_dir()
+        .unwrap_or_else(|| PathBuf::from("/tmp"))
+        .join("rollcron");
+
+    let repo_name = source
+        .trim_end_matches('/')
+        .trim_end_matches(".git")
+        .rsplit('/')
+        .next()
+        .unwrap_or("repo");
+
+    let random_suffix = generate_random_suffix();
+    cache_base.join(format!("{}-{}", repo_name, random_suffix))
+}
+
+/// Clones repo to specified cache path.
+pub fn clone_to(source: &str, cache_dir: &Path) -> Result<()> {
     if let Some(parent) = cache_dir.parent() {
         std::fs::create_dir_all(parent)?;
     }
-
-    let update_info = if cache_dir.exists() {
-        sync_repo(&cache_dir)?
-    } else {
-        clone_repo(source, &cache_dir)?;
-        Some("initial".to_string())
-    };
-
-    Ok((cache_dir, update_info))
+    clone_repo(source, cache_dir)
 }
 
 fn clone_repo(source: &str, dest: &Path) -> Result<()> {
@@ -59,8 +67,8 @@ fn clone_repo(source: &str, dest: &Path) -> Result<()> {
     Ok(())
 }
 
-/// Returns commit range (e.g. "abc123..def456") if new commits were fetched
-fn sync_repo(dest: &Path) -> Result<Option<String>> {
+/// Syncs an existing repo. Returns commit range (e.g. "abc123..def456") if new commits were fetched.
+pub fn sync_repo(dest: &Path) -> Result<Option<String>> {
     // git clone sets up tracking branches for both local and remote repos
     let has_upstream = Command::new("git")
         .args(["rev-parse", "--abbrev-ref", "@{upstream}"])
@@ -128,29 +136,15 @@ fn sync_repo(dest: &Path) -> Result<Option<String>> {
     Ok(None)
 }
 
-fn get_cache_dir(source: &str) -> Result<PathBuf> {
-    let cache_base = dirs::cache_dir()
-        .unwrap_or_else(|| PathBuf::from("/tmp"))
-        .join("rollcron");
-
-    let repo_name = source
-        .trim_end_matches('/')
-        .trim_end_matches(".git")
-        .rsplit('/')
-        .next()
-        .unwrap_or("repo");
-
-    let hash = &format!("{:x}", hash_str(source))[..8];
-
-    Ok(cache_base.join(format!("{}-{}", repo_name, hash)))
-}
-
-fn hash_str(input: &str) -> u64 {
-    use std::collections::hash_map::DefaultHasher;
-    use std::hash::{Hash, Hasher};
-    let mut hasher = DefaultHasher::new();
-    input.hash(&mut hasher);
-    hasher.finish()
+fn generate_random_suffix() -> String {
+    use std::time::{SystemTime, UNIX_EPOCH};
+    let nanos = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_nanos())
+        .unwrap_or(0);
+    // Use lower 32 bits of nanoseconds XOR'd with process ID for uniqueness
+    let unique = (nanos as u32) ^ std::process::id();
+    format!("{:08x}", unique)
 }
 
 pub fn get_job_dir(sot_path: &Path, job_id: &str) -> PathBuf {
@@ -252,13 +246,44 @@ pub fn sync_to_job_dir(sot_path: &Path, job_dir: &Path) -> Result<()> {
     Ok(())
 }
 
+/// Removes the sot_path and all associated job directories.
+pub fn cleanup_cache_dir(sot_path: &Path, job_ids: &[String]) {
+    use tracing::info;
+
+    // Remove job directories
+    for job_id in job_ids {
+        let job_dir = get_job_dir(sot_path, job_id);
+        if job_dir.exists() {
+            info!(path = %job_dir.display(), "Removing job directory");
+            let _ = std::fs::remove_dir_all(&job_dir);
+        }
+        // Also remove temp/old variants
+        let _ = std::fs::remove_dir_all(job_dir.with_extension("tmp"));
+        let _ = std::fs::remove_dir_all(job_dir.with_extension("old"));
+    }
+
+    // Remove sot_path
+    if sot_path.exists() {
+        info!(path = %sot_path.display(), "Removing cache directory");
+        let _ = std::fs::remove_dir_all(sot_path);
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
-    fn cache_dir_from_url() {
-        let dir = get_cache_dir("https://github.com/user/myrepo.git").unwrap();
+    fn cache_path_from_url() {
+        let dir = generate_cache_path("https://github.com/user/myrepo.git");
         assert!(dir.to_str().unwrap().contains("myrepo"));
     }
+
+    #[test]
+    fn cache_path_is_random() {
+        let dir1 = generate_cache_path("https://github.com/user/repo.git");
+        std::thread::sleep(std::time::Duration::from_millis(1));
+        let dir2 = generate_cache_path("https://github.com/user/repo.git");
+        assert_ne!(dir1, dir2);
+    }
 }

src/main.rs

@@ -5,7 +5,7 @@ mod git;
 mod logging;
 mod webhook;
 
-use actor::runner::{GracefulShutdown, Initialize, RunnerActor};
+use actor::runner::{GetJobIds, GracefulShutdown, Initialize, RunnerActor};
 use anyhow::{Context, Result};
 use clap::Parser;
 use std::path::PathBuf;
@@ -45,18 +45,18 @@ async fn main() -> Result<()> {
 
     info!(source = %source, pull_interval = args.pull_interval, "Starting rollcron");
 
-    // Initial sync
-    let (sot_path, _) = git::ensure_repo(&source)?;
+    // Initial clone
+    let sot_path = git::generate_cache_path(&source);
+    git::clone_to(&source, &sot_path)?;
     info!(cache = %sot_path.display(), "Repository ready");
 
     let (initial_runner, initial_jobs) = load_config(&sot_path)?;
 
     // Spawn Runner actor
     let runner = xtra::spawn_tokio(
         RunnerActor::new(
-            source,
             Duration::from_secs(args.pull_interval),
-            sot_path,
+            sot_path.clone(),
             initial_runner,
         ),
         Mailbox::unbounded(),
@@ -72,9 +72,15 @@ async fn main() -> Result<()> {
     tokio::signal::ctrl_c().await?;
     info!("Shutting down...");
 
+    // Get job IDs for cleanup
+    let job_ids = runner.send(GetJobIds).await.unwrap_or_default();
+
     // Graceful shutdown
     let _ = runner.send(GracefulShutdown).await;
 
+    // Cleanup cache directories
+    git::cleanup_cache_dir(&sot_path, &job_ids);
+
     Ok(())
 }