harald/zeroclaw
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 3

chore: Remove blocking read strings

Browse source
This commit is contained in:
Jayson Reis 2026-02-18 15:52:07 +00:00 • committed by Chummy
parent bc0be9a3c1
commit b9af601943
26 changed files with 331 additions and 243 deletions
Download patch file Download diff file Expand all files Collapse all files

5
src/tools/browser.rs
View file

@ -1225,8 +1225,9 @@ mod native_backend {
});
if let Some(path_str) = path {
std::fs::write(&path_str, &png)
.with_context(|| format!("Failed to write screenshot to {path_str}"))?;
tokio::fs::write(&path_str, &png).await.with_context(|| {
format!("Failed to write screenshot to {path_str}")
})?;
payload["path"] = Value::String(path_str);
} else {
payload["png_base64"] =

12
src/tools/cron_add.rs
View file

@ -217,13 +217,13 @@ mod tests {
use crate::security::AutonomyLevel;
use tempfile::TempDir;
fn test_config(tmp: &TempDir) -> Arc<Config> {
async fn test_config(tmp: &TempDir) -> Arc<Config> {
let config = Config {
workspace_dir: tmp.path().join("workspace"),
config_path: tmp.path().join("config.toml"),
..Config::default()
};
std::fs::create_dir_all(&config.workspace_dir).unwrap();
tokio::fs::create_dir_all(&config.workspace_dir).await.unwrap();
Arc::new(config)
}
@ -237,7 +237,7 @@ mod tests {
#[tokio::test]
async fn adds_shell_job() {
let tmp = TempDir::new().unwrap();
let cfg = test_config(&tmp);
let cfg = test_config(&tmp).await;
let tool = CronAddTool::new(cfg.clone(), test_security(&cfg));
let result = tool
.execute(json!({
@ -262,7 +262,7 @@ mod tests {
};
config.autonomy.allowed_commands = vec!["echo".into()];
config.autonomy.level = AutonomyLevel::Supervised;
std::fs::create_dir_all(&config.workspace_dir).unwrap();
tokio::fs::create_dir_all(&config.workspace_dir).await.unwrap();
let cfg = Arc::new(config);
let tool = CronAddTool::new(cfg.clone(), test_security(&cfg));
@ -285,7 +285,7 @@ mod tests {
#[tokio::test]
async fn rejects_invalid_schedule() {
let tmp = TempDir::new().unwrap();
let cfg = test_config(&tmp);
let cfg = test_config(&tmp).await;
let tool = CronAddTool::new(cfg.clone(), test_security(&cfg));
let result = tool
@ -307,7 +307,7 @@ mod tests {
#[tokio::test]
async fn agent_job_requires_prompt() {
let tmp = TempDir::new().unwrap();
let cfg = test_config(&tmp);
let cfg = test_config(&tmp).await;
let tool = CronAddTool::new(cfg.clone(), test_security(&cfg));
let result = tool

8
src/tools/cron_list.rs
View file

@ -63,20 +63,20 @@ mod tests {
use crate::config::Config;
use tempfile::TempDir;
fn test_config(tmp: &TempDir) -> Arc<Config> {
async fn test_config(tmp: &TempDir) -> Arc<Config> {
let config = Config {
workspace_dir: tmp.path().join("workspace"),
config_path: tmp.path().join("config.toml"),
..Config::default()
};
std::fs::create_dir_all(&config.workspace_dir).unwrap();
tokio::fs::create_dir_all(&config.workspace_dir).await.unwrap();
Arc::new(config)
}
#[tokio::test]
async fn returns_empty_list_when_no_jobs() {
let tmp = TempDir::new().unwrap();
let cfg = test_config(&tmp);
let cfg = test_config(&tmp).await;
let tool = CronListTool::new(cfg);
let result = tool.execute(json!({})).await.unwrap();
@ -87,7 +87,7 @@ mod tests {
#[tokio::test]
async fn errors_when_cron_disabled() {
let tmp = TempDir::new().unwrap();
let mut cfg = (*test_config(&tmp)).clone();
let mut cfg = (*test_config(&tmp).await).clone();
cfg.cron.enabled = false;
let tool = CronListTool::new(Arc::new(cfg));

8
src/tools/cron_remove.rs
View file

@ -76,20 +76,20 @@ mod tests {
use crate::config::Config;
use tempfile::TempDir;
fn test_config(tmp: &TempDir) -> Arc<Config> {
async fn test_config(tmp: &TempDir) -> Arc<Config> {
let config = Config {
workspace_dir: tmp.path().join("workspace"),
config_path: tmp.path().join("config.toml"),
..Config::default()
};
std::fs::create_dir_all(&config.workspace_dir).unwrap();
tokio::fs::create_dir_all(&config.workspace_dir).await.unwrap();
Arc::new(config)
}
#[tokio::test]
async fn removes_existing_job() {
let tmp = TempDir::new().unwrap();
let cfg = test_config(&tmp);
let cfg = test_config(&tmp).await;
let job = cron::add_job(&cfg, "*/5 * * * *", "echo ok").unwrap();
let tool = CronRemoveTool::new(cfg.clone());
@ -101,7 +101,7 @@ mod tests {
#[tokio::test]
async fn errors_when_job_id_missing() {
let tmp = TempDir::new().unwrap();
let cfg = test_config(&tmp);
let cfg = test_config(&tmp).await;
let tool = CronRemoveTool::new(cfg);
let result = tool.execute(json!({})).await.unwrap();

8
src/tools/cron_run.rs
View file

@ -107,20 +107,20 @@ mod tests {
use crate::config::Config;
use tempfile::TempDir;
fn test_config(tmp: &TempDir) -> Arc<Config> {
async fn test_config(tmp: &TempDir) -> Arc<Config> {
let config = Config {
workspace_dir: tmp.path().join("workspace"),
config_path: tmp.path().join("config.toml"),
..Config::default()
};
std::fs::create_dir_all(&config.workspace_dir).unwrap();
tokio::fs::create_dir_all(&config.workspace_dir).await.unwrap();
Arc::new(config)
}
#[tokio::test]
async fn force_runs_job_and_records_history() {
let tmp = TempDir::new().unwrap();
let cfg = test_config(&tmp);
let cfg = test_config(&tmp).await;
let job = cron::add_job(&cfg, "*/5 * * * *", "echo run-now").unwrap();
let tool = CronRunTool::new(cfg.clone());
@ -134,7 +134,7 @@ mod tests {
#[tokio::test]
async fn errors_for_missing_job() {
let tmp = TempDir::new().unwrap();
let cfg = test_config(&tmp);
let cfg = test_config(&tmp).await;
let tool = CronRunTool::new(cfg);
let result = tool

8
src/tools/cron_runs.rs
View file

@ -121,20 +121,20 @@ mod tests {
use chrono::{Duration as ChronoDuration, Utc};
use tempfile::TempDir;
fn test_config(tmp: &TempDir) -> Arc<Config> {
async fn test_config(tmp: &TempDir) -> Arc<Config> {
let config = Config {
workspace_dir: tmp.path().join("workspace"),
config_path: tmp.path().join("config.toml"),
..Config::default()
};
std::fs::create_dir_all(&config.workspace_dir).unwrap();
tokio::fs::create_dir_all(&config.workspace_dir).await.unwrap();
Arc::new(config)
}
#[tokio::test]
async fn lists_runs_with_truncation() {
let tmp = TempDir::new().unwrap();
let cfg = test_config(&tmp);
let cfg = test_config(&tmp).await;
let job = cron::add_job(&cfg, "*/5 * * * *", "echo ok").unwrap();
let long_output = "x".repeat(1000);
@ -163,7 +163,7 @@ mod tests {
#[tokio::test]
async fn errors_when_job_id_missing() {
let tmp = TempDir::new().unwrap();
let cfg = test_config(&tmp);
let cfg = test_config(&tmp).await;
let tool = CronRunsTool::new(cfg);
let result = tool.execute(json!({})).await.unwrap();
assert!(!result.success);

8
src/tools/cron_update.rs
View file

@ -111,13 +111,13 @@ mod tests {
use crate::config::Config;
use tempfile::TempDir;
fn test_config(tmp: &TempDir) -> Arc<Config> {
async fn test_config(tmp: &TempDir) -> Arc<Config> {
let config = Config {
workspace_dir: tmp.path().join("workspace"),
config_path: tmp.path().join("config.toml"),
..Config::default()
};
std::fs::create_dir_all(&config.workspace_dir).unwrap();
tokio::fs::create_dir_all(&config.workspace_dir).await.unwrap();
Arc::new(config)
}
@ -131,7 +131,7 @@ mod tests {
#[tokio::test]
async fn updates_enabled_flag() {
let tmp = TempDir::new().unwrap();
let cfg = test_config(&tmp);
let cfg = test_config(&tmp).await;
let job = cron::add_job(&cfg, "*/5 * * * *", "echo ok").unwrap();
let tool = CronUpdateTool::new(cfg.clone(), test_security(&cfg));
@ -156,7 +156,7 @@ mod tests {
..Config::default()
};
config.autonomy.allowed_commands = vec!["echo".into()];
std::fs::create_dir_all(&config.workspace_dir).unwrap();
tokio::fs::create_dir_all(&config.workspace_dir).await.unwrap();
let cfg = Arc::new(config);
let job = cron::add_job(&cfg, "*/5 * * * *", "echo ok").unwrap();
let tool = CronUpdateTool::new(cfg.clone(), test_security(&cfg));

12
src/tools/image_info.rs
View file

@ -428,7 +428,7 @@ mod tests {
async fn execute_real_file() {
// Create a minimal valid PNG
let dir = std::env::temp_dir().join("zeroclaw_image_info_test");
let _ = std::fs::create_dir_all(&dir);
let _ = tokio::fs::create_dir_all(&dir).await;
let png_path = dir.join("test.png");
// Minimal 1x1 red PNG (67 bytes)
@ -448,7 +448,7 @@ mod tests {
0x49, 0x45, 0x4E, 0x44, // IEND
0xAE, 0x42, 0x60, 0x82, // CRC
];
std::fs::write(&png_path, &png_bytes).unwrap();
tokio::fs::write(&png_path, &png_bytes).await.unwrap();
let tool = ImageInfoTool::new(test_security());
let result = tool
@ -461,13 +461,13 @@ mod tests {
assert!(!result.output.contains("data:"));
// Clean up
let _ = std::fs::remove_dir_all(&dir);
let _ = tokio::fs::remove_dir_all(&dir).await;
}
#[tokio::test]
async fn execute_with_base64() {
let dir = std::env::temp_dir().join("zeroclaw_image_info_b64");
let _ = std::fs::create_dir_all(&dir);
let _ = tokio::fs::create_dir_all(&dir).await;
let png_path = dir.join("test_b64.png");
// Minimal 1x1 PNG
@ -478,7 +478,7 @@ mod tests {
0xD7, 0x63, 0xF8, 0xCF, 0xC0, 0x00, 0x00, 0x00, 0x02, 0x00, 0x01, 0xE2, 0x21, 0xBC,
0x33, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82,
];
std::fs::write(&png_path, &png_bytes).unwrap();
tokio::fs::write(&png_path, &png_bytes).await.unwrap();
let tool = ImageInfoTool::new(test_security());
let result = tool
@ -488,6 +488,6 @@ mod tests {
assert!(result.success);
assert!(result.output.contains("data:image/png;base64,"));
let _ = std::fs::remove_dir_all(&dir);
let _ = tokio::fs::remove_dir_all(&dir).await;
}
}

43
src/tools/pushover.rs
View file

@ -41,9 +41,10 @@ impl PushoverTool {
)
}
fn get_credentials(&self) -> anyhow::Result<(String, String)> {
async fn get_credentials(&self) -> anyhow::Result<(String, String)> {
let env_path = self.workspace_dir.join(".env");
let content = std::fs::read_to_string(&env_path)
let content = tokio::fs::read_to_string(&env_path)
.await
.map_err(|e| anyhow::anyhow!("Failed to read {}: {}", env_path.display(), e))?;
let mut token = None;
@ -153,7 +154,7 @@ impl Tool for PushoverTool {
let sound = args.get("sound").and_then(|v| v.as_str()).map(String::from);
let (token, user_key) = self.get_credentials()?;
let (token, user_key) = self.get_credentials().await?;
let mut form = reqwest::multipart::Form::new()
.text("token", token)
@ -269,8 +270,8 @@ mod tests {
assert!(required.contains(&serde_json::Value::String("message".to_string())));
}
#[test]
fn credentials_parsed_from_env_file() {
#[tokio::test]
async fn credentials_parsed_from_env_file() {
let tmp = TempDir::new().unwrap();
let env_path = tmp.path().join(".env");
fs::write(
@ -283,7 +284,7 @@ mod tests {
test_security(AutonomyLevel::Full, 100),
tmp.path().to_path_buf(),
);
let result = tool.get_credentials();
let result = tool.get_credentials().await;
assert!(result.is_ok());
let (token, user_key) = result.unwrap();
@ -291,20 +292,20 @@ mod tests {
assert_eq!(user_key, "userkey456");
}
#[test]
fn credentials_fail_without_env_file() {
#[tokio::test]
async fn credentials_fail_without_env_file() {
let tmp = TempDir::new().unwrap();
let tool = PushoverTool::new(
test_security(AutonomyLevel::Full, 100),
tmp.path().to_path_buf(),
);
let result = tool.get_credentials();
let result = tool.get_credentials().await;
assert!(result.is_err());
}
#[test]
fn credentials_fail_without_token() {
#[tokio::test]
async fn credentials_fail_without_token() {
let tmp = TempDir::new().unwrap();
let env_path = tmp.path().join(".env");
fs::write(&env_path, "PUSHOVER_USER_KEY=userkey456\n").unwrap();
@ -313,13 +314,13 @@ mod tests {
test_security(AutonomyLevel::Full, 100),
tmp.path().to_path_buf(),
);
let result = tool.get_credentials();
let result = tool.get_credentials().await;
assert!(result.is_err());
}
#[test]
fn credentials_fail_without_user_key() {
#[tokio::test]
async fn credentials_fail_without_user_key() {
let tmp = TempDir::new().unwrap();
let env_path = tmp.path().join(".env");
fs::write(&env_path, "PUSHOVER_TOKEN=testtoken123\n").unwrap();
@ -328,13 +329,13 @@ mod tests {
test_security(AutonomyLevel::Full, 100),
tmp.path().to_path_buf(),
);
let result = tool.get_credentials();
let result = tool.get_credentials().await;
assert!(result.is_err());
}
#[test]
fn credentials_ignore_comments() {
#[tokio::test]
async fn credentials_ignore_comments() {
let tmp = TempDir::new().unwrap();
let env_path = tmp.path().join(".env");
fs::write(&env_path, "# This is a comment\nPUSHOVER_TOKEN=realtoken\n# Another comment\nPUSHOVER_USER_KEY=realuser\n").unwrap();
@ -343,7 +344,7 @@ mod tests {
test_security(AutonomyLevel::Full, 100),
tmp.path().to_path_buf(),
);
let result = tool.get_credentials();
let result = tool.get_credentials().await;
assert!(result.is_ok());
let (token, user_key) = result.unwrap();
@ -371,8 +372,8 @@ mod tests {
assert!(schema["properties"].get("sound").is_some());
}
#[test]
fn credentials_support_export_and_quoted_values() {
#[tokio::test]
async fn credentials_support_export_and_quoted_values() {
let tmp = TempDir::new().unwrap();
let env_path = tmp.path().join(".env");
fs::write(
@ -385,7 +386,7 @@ mod tests {
test_security(AutonomyLevel::Full, 100),
tmp.path().to_path_buf(),
);
let result = tool.get_credentials();
let result = tool.get_credentials().await;
assert!(result.is_ok());
let (token, user_key) = result.unwrap();

20
src/tools/schedule.rs
View file

@ -368,14 +368,14 @@ mod tests {
use crate::security::AutonomyLevel;
use tempfile::TempDir;
fn test_setup() -> (TempDir, Config, Arc<SecurityPolicy>) {
async fn test_setup() -> (TempDir, Config, Arc<SecurityPolicy>) {
let tmp = TempDir::new().unwrap();
let config = Config {
workspace_dir: tmp.path().join("workspace"),
config_path: tmp.path().join("config.toml"),
..Config::default()
};
std::fs::create_dir_all(&config.workspace_dir).unwrap();
tokio::fs::create_dir_all(&config.workspace_dir).await.unwrap();
let security = Arc::new(SecurityPolicy::from_config(
&config.autonomy,
&config.workspace_dir,
@ -383,9 +383,9 @@ mod tests {
(tmp, config, security)
}
#[test]
fn tool_name_and_schema() {
let (_tmp, config, security) = test_setup();
#[tokio::test]
async fn tool_name_and_schema() {
let (_tmp, config, security) = test_setup().await;
let tool = ScheduleTool::new(security, config);
assert_eq!(tool.name(), "schedule");
let schema = tool.parameters_schema();
@ -394,7 +394,7 @@ mod tests {
#[tokio::test]
async fn list_empty() {
let (_tmp, config, security) = test_setup();
let (_tmp, config, security) = test_setup().await;
let tool = ScheduleTool::new(security, config);
let result = tool.execute(json!({"action": "list"})).await.unwrap();
@ -404,7 +404,7 @@ mod tests {
#[tokio::test]
async fn create_get_and_cancel_roundtrip() {
let (_tmp, config, security) = test_setup();
let (_tmp, config, security) = test_setup().await;
let tool = ScheduleTool::new(security, config);
let create = tool
@ -440,7 +440,7 @@ mod tests {
#[tokio::test]
async fn once_and_pause_resume_aliases_work() {
let (_tmp, config, security) = test_setup();
let (_tmp, config, security) = test_setup().await;
let tool = ScheduleTool::new(security, config);
let once = tool
@ -489,7 +489,7 @@ mod tests {
},
..Config::default()
};
std::fs::create_dir_all(&config.workspace_dir).unwrap();
tokio::fs::create_dir_all(&config.workspace_dir).await.unwrap();
let security = Arc::new(SecurityPolicy::from_config(
&config.autonomy,
&config.workspace_dir,
@ -514,7 +514,7 @@ mod tests {
#[tokio::test]
async fn unknown_action_returns_failure() {
let (_tmp, config, security) = test_setup();
let (_tmp, config, security) = test_setup().await;
let tool = ScheduleTool::new(security, config);
let result = tool.execute(json!({"action": "explode"})).await.unwrap();

2
src/tools/shell.rs
View file

@ -363,7 +363,7 @@ mod tests {
.unwrap();
assert!(allowed.success);
let _ = std::fs::remove_file(std::env::temp_dir().join("zeroclaw_shell_approval_test"));
let _ = tokio::fs::remove_file(std::env::temp_dir().join("zeroclaw_shell_approval_test")).await;
}
// ── §5.2 Shell timeout enforcement tests ─────────────────