78 lines
2.4 KiB
Rust
78 lines
2.4 KiB
Rust
//! Read-only view of bash task state files for `get_loose_ends`.
|
|
//!
|
|
//! The task runner and MCP tools live in `hive-bash-mcp`. This module
|
|
//! only reads the JSON task files that the daemon writes — no subprocess
|
|
//! logic, no wake signals, no dep on the hive-bash-mcp crate.
|
|
//!
|
|
//! Task files live under `harness_dir/bash-tasks/<id>.json`. The JSON
|
|
//! schema is owned by `hive-bash-mcp::protocol::TaskFile`; this module
|
|
//! duplicates only the fields the harness needs for `get_loose_ends`.
|
|
|
|
use std::path::PathBuf;
|
|
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
/// Lifecycle state of a bash task (mirrors `hive_bash_mcp::protocol::TaskStatus`).
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
|
#[serde(rename_all = "snake_case")]
|
|
pub enum TaskStatus {
|
|
Pending,
|
|
Running,
|
|
Done,
|
|
TimedOut,
|
|
Interrupted,
|
|
}
|
|
|
|
/// Minimal task metadata (mirrors `hive_bash_mcp::protocol::TaskFile`).
|
|
#[derive(Debug, Clone, Deserialize)]
|
|
pub struct TaskFile {
|
|
pub id: String,
|
|
pub cmd: String,
|
|
pub status: TaskStatus,
|
|
pub created_at: i64,
|
|
}
|
|
|
|
fn tasks_dir() -> PathBuf {
|
|
let base = if let Some(p) = std::env::var_os("HYPERHIVE_HARNESS_DIR") {
|
|
PathBuf::from(p)
|
|
} else {
|
|
let state = std::env::var("HYPERHIVE_STATE_DIR").unwrap_or_default();
|
|
let state_path = PathBuf::from(&state);
|
|
state_path
|
|
.parent()
|
|
.map(|p| p.join("harness"))
|
|
.unwrap_or_else(|| PathBuf::from(state))
|
|
};
|
|
base.join("bash-tasks")
|
|
}
|
|
|
|
/// Read a task file by ID. Returns `None` if missing or unparseable.
|
|
#[must_use]
|
|
pub fn read_task(id: &str) -> Option<TaskFile> {
|
|
let path = tasks_dir().join(format!("{id}.json"));
|
|
let s = std::fs::read_to_string(path).ok()?;
|
|
serde_json::from_str(&s).ok()
|
|
}
|
|
|
|
/// Return all tasks currently in `Pending` or `Running` state.
|
|
#[must_use]
|
|
pub fn active_tasks() -> Vec<TaskFile> {
|
|
let Ok(rd) = std::fs::read_dir(tasks_dir()) else {
|
|
return Vec::new();
|
|
};
|
|
let mut out = Vec::new();
|
|
for entry in rd.flatten() {
|
|
let path = entry.path();
|
|
if path.extension().and_then(|e| e.to_str()) != Some("json") {
|
|
continue;
|
|
}
|
|
let Some(id) = path.file_stem().and_then(|s| s.to_str()).map(str::to_owned) else {
|
|
continue;
|
|
};
|
|
let Some(task) = read_task(&id) else { continue };
|
|
if matches!(task.status, TaskStatus::Pending | TaskStatus::Running) {
|
|
out.push(task);
|
|
}
|
|
}
|
|
out
|
|
}
|