feat: runner rotation detection with polling and CI/headless mode (#3)

- Add TOML config (config.rs) with poll_interval_secs, poll_timeout_secs, gitlab_host, gitlab_token

- Extend RunnerManager with platform and architecture optional fields

- Add detect_rotating_runners() to Conductor (runners with >1 manager)

- Add Rotate variant to Command enum, wire into execute_search and UI

- Add rotation table renderer with old/new manager comparison

- Add polling toggle (p key) with timer in header and auto-refresh

- Add --watch, --command, --tags CLI flags for headless/CI mode

- Bump version to 0.3.0

- 51 tests passing, clippy clean, fmt clean

Author: damacus

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "gitlab-runner-tui"
-version = "0.1.0"
+version = "0.3.0"
 edition = "2021"
 
 [dependencies]
@@ -27,6 +27,8 @@ anyhow = "1.0"
 # CLI & Config
 clap = { version = "4.5", features = ["derive", "env"] }
 dotenvy = "0.15"
+toml = "0.8"
+dirs = "5.0"
 
 # Utility
 chrono = { version = "0.4", features = ["serde"] }

Cargo.toml

@@ -133,6 +133,15 @@ impl Conductor {
             .collect();
         Ok(empty)
     }
+
+    pub async fn detect_rotating_runners(&self, filters: RunnerFilters) -> Result<Vec<Runner>> {
+        let runners = self.fetch_runners(filters).await?;
+        let rotating = runners
+            .into_iter()
+            .filter(|r| r.managers.len() > 1)
+            .collect();
+        Ok(rotating)
+    }
 }
 
 #[cfg(test)]
@@ -430,4 +439,125 @@ mod tests {
             mock.assert_async().await;
         }
     }
+
+    #[tokio::test]
+    async fn test_detect_rotating_runners_finds_multi_manager() {
+        let mut server = Server::new_async().await;
+        let mocks = setup_runner_mocks(
+            &mut server,
+            &[
+                // Runner 1: two managers (rotation in progress)
+                (1, "online", &["prod"], &[(10, "online"), (11, "offline")]),
+                // Runner 2: single manager (no rotation)
+                (2, "online", &["staging"], &[(20, "online")]),
+            ],
+        )
+        .await;
+
+        let client = GitLabClient::new(server.url(), "test-token".to_string()).unwrap();
+        let conductor = Conductor::new(client);
+
+        let rotating = conductor
+            .detect_rotating_runners(RunnerFilters::default())
+            .await
+            .unwrap();
+
+        assert_eq!(rotating.len(), 1);
+        assert_eq!(rotating[0].id, 1);
+        assert_eq!(rotating[0].managers.len(), 2);
+
+        for mock in &mocks {
+            mock.assert_async().await;
+        }
+    }
+
+    #[tokio::test]
+    async fn test_detect_rotating_runners_empty_when_no_rotation() {
+        let mut server = Server::new_async().await;
+        let mocks = setup_runner_mocks(
+            &mut server,
+            &[
+                (1, "online", &["prod"], &[(10, "online")]),
+                (2, "online", &["staging"], &[(20, "online")]),
+            ],
+        )
+        .await;
+
+        let client = GitLabClient::new(server.url(), "test-token".to_string()).unwrap();
+        let conductor = Conductor::new(client);
+
+        let rotating = conductor
+            .detect_rotating_runners(RunnerFilters::default())
+            .await
+            .unwrap();
+
+        assert!(rotating.is_empty());
+
+        for mock in &mocks {
+            mock.assert_async().await;
+        }
+    }
+
+    #[tokio::test]
+    async fn test_detect_rotating_runners_excludes_no_managers() {
+        let mut server = Server::new_async().await;
+        let mocks = setup_runner_mocks(
+            &mut server,
+            &[
+                (1, "online", &["prod"], &[]),
+                (
+                    2,
+                    "online",
+                    &["staging"],
+                    &[(20, "offline"), (21, "online")],
+                ),
+            ],
+        )
+        .await;
+
+        let client = GitLabClient::new(server.url(), "test-token".to_string()).unwrap();
+        let conductor = Conductor::new(client);
+
+        let rotating = conductor
+            .detect_rotating_runners(RunnerFilters::default())
+            .await
+            .unwrap();
+
+        assert_eq!(rotating.len(), 1);
+        assert_eq!(rotating[0].id, 2);
+
+        for mock in &mocks {
+            mock.assert_async().await;
+        }
+    }
+
+    #[tokio::test]
+    async fn test_detect_rotating_runners_three_managers() {
+        let mut server = Server::new_async().await;
+        let mocks = setup_runner_mocks(
+            &mut server,
+            &[(
+                1,
+                "online",
+                &["prod"],
+                &[(10, "offline"), (11, "stale"), (12, "online")],
+            )],
+        )
+        .await;
+
+        let client = GitLabClient::new(server.url(), "test-token".to_string()).unwrap();
+        let conductor = Conductor::new(client);
+
+        let rotating = conductor
+            .detect_rotating_runners(RunnerFilters::default())
+            .await
+            .unwrap();
+
+        assert_eq!(rotating.len(), 1);
+        assert_eq!(rotating[0].managers.len(), 3);
+
+        for mock in &mocks {
+            mock.assert_async().await;
+        }
+    }
 }