eeymoo/claw-code
1
0
Fork 0
mirror of https://github.com/instructkr/claw-code.git synced 2026-04-09 01:24:49 +08:00
Code Issues Packages Projects Releases Wiki Activity

style: cargo fmt — fix CI formatting failures

Browse Source 
Pre-existing formatting issues in anthropic.rs surfaced by CI cargo fmt check.
No functional changes.
This commit is contained in:
YeonGyu-Kim
2026-04-08 11:21:13 +09:00
parent 000aed4188
commit c7b3296ef6
11 changed files with 251 additions and 202 deletions
Download Patch File Download Diff File Expand all files Collapse all files

165
rust/crates/tools/src/lib.rs
View File

@@ -1244,10 +1244,8 @@ fn execute_tool_with_enforcer(
}
"WorkerRestart" => from_value::<WorkerIdInput>(input).and_then(run_worker_restart),
"WorkerTerminate" => from_value::<WorkerIdInput>(input).and_then(run_worker_terminate),
"WorkerObserveCompletion" => {
from_value::<WorkerObserveCompletionInput>(input)
.and_then(run_worker_observe_completion)
}
"WorkerObserveCompletion" => from_value::<WorkerObserveCompletionInput>(input)
.and_then(run_worker_observe_completion),
"TeamCreate" => from_value::<TeamCreateInput>(input).and_then(run_team_create),
"TeamDelete" => from_value::<TeamDeleteInput>(input).and_then(run_team_delete),
"CronCreate" => from_value::<CronCreateInput>(input).and_then(run_cron_create),
@@ -1510,9 +1508,7 @@ fn run_worker_terminate(input: WorkerIdInput) -> Result<String, String> {
}
#[allow(clippy::needless_pass_by_value)]
fn run_worker_observe_completion(
input: WorkerObserveCompletionInput,
) -> Result<String, String> {
fn run_worker_observe_completion(input: WorkerObserveCompletionInput) -> Result<String, String> {
let worker = global_worker_registry().observe_completion(
&input.worker_id,
&input.finish_reason,
@@ -3826,7 +3822,8 @@ impl ApiClient for ProviderRuntimeClient {
})
.collect::<Vec<_>>();
let messages = convert_messages(&request.messages);
let system = (!request.system_prompt.is_empty()).then(|| request.system_prompt.join("\n\n"));
let system =
(!request.system_prompt.is_empty()).then(|| request.system_prompt.join("\n\n"));
let tool_choice = (!self.allowed_tools.is_empty()).then_some(ToolChoice::Auto);
let runtime = &self.runtime;
@@ -5379,8 +5376,8 @@ mod tests {
GlobalToolRegistry, LaneEventName, LaneFailureClass, ProviderRuntimeClient,
SubagentToolExecutor,
};
use runtime::ProviderFallbackConfig;
use api::OutputContentBlock;
use runtime::ProviderFallbackConfig;
use runtime::{
permission_enforcer::PermissionEnforcer, ApiRequest, AssistantEvent, ConversationRuntime,
PermissionMode, PermissionPolicy, RuntimeError, Session, TaskPacket, ToolExecutor,
@@ -5566,11 +5563,7 @@ mod tests {
// Use the actual OS temp dir so the worktree path matches the allowlist
let tmp_root = std::env::temp_dir().to_str().expect("utf-8").to_string();
let settings = format!("{{\"trustedRoots\": [\"{tmp_root}\"]}}");
fs::write(
claw_dir.join("settings.json"),
settings,
)
.expect("write settings");
fs::write(claw_dir.join("settings.json"), settings).expect("write settings");
// WorkerCreate with no per-call trusted_roots — config should supply them
let cwd = worktree.to_str().expect("valid utf-8").to_string();
@@ -5605,13 +5598,13 @@ mod tests {
let worker_id = output["worker_id"].as_str().expect("worker_id").to_string();
// Terminate
let terminated = execute_tool(
"WorkerTerminate",
&json!({"worker_id": worker_id}),
)
.expect("WorkerTerminate should succeed");
let terminated = execute_tool("WorkerTerminate", &json!({"worker_id": worker_id}))
.expect("WorkerTerminate should succeed");
let term_output: serde_json::Value = serde_json::from_str(&terminated).expect("json");
assert_eq!(term_output["status"], "finished", "terminated worker should be finished");
assert_eq!(
term_output["status"], "finished",
"terminated worker should be finished"
);
assert_eq!(
term_output["prompt_in_flight"], false,
"prompt_in_flight should be cleared on termination"
@@ -5637,11 +5630,8 @@ mod tests {
.expect("WorkerObserve should succeed");
// Restart
let restarted = execute_tool(
"WorkerRestart",
&json!({"worker_id": worker_id}),
)
.expect("WorkerRestart should succeed");
let restarted = execute_tool("WorkerRestart", &json!({"worker_id": worker_id}))
.expect("WorkerRestart should succeed");
let restart_output: serde_json::Value = serde_json::from_str(&restarted).expect("json");
assert_eq!(
restart_output["status"], "spawning",
@@ -5667,11 +5657,8 @@ mod tests {
let created_output: serde_json::Value = serde_json::from_str(&created).expect("json");
let worker_id = created_output["worker_id"].as_str().expect("worker_id");
let fetched = execute_tool(
"WorkerGet",
&json!({"worker_id": worker_id}),
)
.expect("WorkerGet should succeed");
let fetched = execute_tool("WorkerGet", &json!({"worker_id": worker_id}))
.expect("WorkerGet should succeed");
let fetched_output: serde_json::Value = serde_json::from_str(&fetched).expect("json");
assert_eq!(fetched_output["worker_id"], worker_id);
assert_eq!(fetched_output["status"], "spawning");
@@ -5705,11 +5692,8 @@ mod tests {
let worker_id = created_output["worker_id"].as_str().expect("worker_id");
// Worker is still in spawning — await_ready should return not-ready snapshot
let snapshot = execute_tool(
"WorkerAwaitReady",
&json!({"worker_id": worker_id}),
)
.expect("WorkerAwaitReady should succeed even when not ready");
let snapshot = execute_tool("WorkerAwaitReady", &json!({"worker_id": worker_id}))
.expect("WorkerAwaitReady should succeed even when not ready");
let snap_output: serde_json::Value = serde_json::from_str(&snapshot).expect("json");
assert_eq!(
snap_output["ready"], false,
@@ -5751,21 +5735,27 @@ mod tests {
let state_path = worktree.join(".claw").join("worker-state.json");
// 1. Create worker WITHOUT trusted_roots
let created = execute_tool(
"WorkerCreate",
&json!({"cwd": cwd}),
)
.expect("WorkerCreate should succeed");
let created = execute_tool("WorkerCreate", &json!({"cwd": cwd}))
.expect("WorkerCreate should succeed");
let created_output: serde_json::Value = serde_json::from_str(&created).expect("json");
let worker_id = created_output["worker_id"].as_str().expect("worker_id").to_string();
let worker_id = created_output["worker_id"]
.as_str()
.expect("worker_id")
.to_string();
// State file should exist after create
assert!(state_path.exists(), "state file should be written after WorkerCreate");
let state: serde_json::Value = serde_json::from_str(
&fs::read_to_string(&state_path).expect("read state")
).expect("parse state");
assert!(
state_path.exists(),
"state file should be written after WorkerCreate"
);
let state: serde_json::Value =
serde_json::from_str(&fs::read_to_string(&state_path).expect("read state"))
.expect("parse state");
assert_eq!(state["status"], "spawning");
assert_eq!(state["is_ready"], false);
assert!(state["seconds_since_update"].is_number(), "seconds_since_update must be present");
assert!(
state["seconds_since_update"].is_number(),
"seconds_since_update must be present"
);
// 2. Force trust_required via observe
execute_tool(
@@ -5773,26 +5763,27 @@ mod tests {
&json!({"worker_id": worker_id, "screen_text": "Do you trust the files in this folder?"}),
)
.expect("WorkerObserve should succeed");
let state: serde_json::Value = serde_json::from_str(
&fs::read_to_string(&state_path).expect("read state")
).expect("parse state");
assert_eq!(state["status"], "trust_required",
"state file must reflect trust_required stall");
let state: serde_json::Value =
serde_json::from_str(&fs::read_to_string(&state_path).expect("read state"))
.expect("parse state");
assert_eq!(
state["status"], "trust_required",
"state file must reflect trust_required stall"
);
assert_eq!(state["is_ready"], false);
assert_eq!(state["trust_gate_cleared"], false);
assert!(state["seconds_since_update"].is_number());
// 3. WorkerResolveTrust -> state file reflects recovery
execute_tool(
"WorkerResolveTrust",
&json!({"worker_id": worker_id}),
)
.expect("WorkerResolveTrust should succeed");
let state: serde_json::Value = serde_json::from_str(
&fs::read_to_string(&state_path).expect("read state")
).expect("parse state");
assert_eq!(state["status"], "spawning",
"state file must show spawning after trust resolved");
execute_tool("WorkerResolveTrust", &json!({"worker_id": worker_id}))
.expect("WorkerResolveTrust should succeed");
let state: serde_json::Value =
serde_json::from_str(&fs::read_to_string(&state_path).expect("read state"))
.expect("parse state");
assert_eq!(
state["status"], "spawning",
"state file must show spawning after trust resolved"
);
assert_eq!(state["trust_gate_cleared"], true);
// 4. Observe ready screen -> state file shows ready_for_prompt
@@ -5801,13 +5792,17 @@ mod tests {
&json!({"worker_id": worker_id, "screen_text": "Ready for input\n>"}),
)
.expect("WorkerObserve ready should succeed");
let state: serde_json::Value = serde_json::from_str(
&fs::read_to_string(&state_path).expect("read state")
).expect("parse state");
assert_eq!(state["status"], "ready_for_prompt",
"state file must show ready_for_prompt after ready screen");
assert_eq!(state["is_ready"], true,
"is_ready must be true in state file at ready_for_prompt");
let state: serde_json::Value =
serde_json::from_str(&fs::read_to_string(&state_path).expect("read state"))
.expect("parse state");
assert_eq!(
state["status"], "ready_for_prompt",
"state file must show ready_for_prompt after ready screen"
);
assert_eq!(
state["is_ready"], true,
"is_ready must be true in state file at ready_for_prompt"
);
fs::remove_dir_all(&worktree).ok();
}
@@ -5815,13 +5810,13 @@ mod tests {
#[test]
fn stall_detect_and_resolve_trust_end_to_end() {
// 1. Create worker WITHOUT trusted_roots so trust won't auto-resolve
let created = execute_tool(
"WorkerCreate",
&json!({"cwd": "/no/trusted/root/here"}),
)
.expect("WorkerCreate should succeed");
let created = execute_tool("WorkerCreate", &json!({"cwd": "/no/trusted/root/here"}))
.expect("WorkerCreate should succeed");
let created_output: serde_json::Value = serde_json::from_str(&created).expect("json");
let worker_id = created_output["worker_id"].as_str().expect("worker_id").to_string();
let worker_id = created_output["worker_id"]
.as_str()
.expect("worker_id")
.to_string();
assert_eq!(created_output["trust_auto_resolve"], false);
// 2. Observe trust prompt screen text -> worker stalls at trust_required
@@ -5840,11 +5835,8 @@ mod tests {
);
assert_eq!(stalled_output["trust_gate_cleared"], false);
// 3. Clawhip calls WorkerResolveTrust to unblock
let resolved = execute_tool(
"WorkerResolveTrust",
&json!({"worker_id": worker_id}),
)
.expect("WorkerResolveTrust should succeed");
let resolved = execute_tool("WorkerResolveTrust", &json!({"worker_id": worker_id}))
.expect("WorkerResolveTrust should succeed");
let resolved_output: serde_json::Value = serde_json::from_str(&resolved).expect("json");
assert_eq!(
resolved_output["status"], "spawning",
@@ -5877,7 +5869,10 @@ mod tests {
)
.expect("WorkerCreate should succeed");
let created_output: serde_json::Value = serde_json::from_str(&created).expect("json");
let worker_id = created_output["worker_id"].as_str().expect("worker_id").to_string();
let worker_id = created_output["worker_id"]
.as_str()
.expect("worker_id")
.to_string();
// Force trust_required
let stalled = execute_tool(
@@ -5892,17 +5887,15 @@ mod tests {
assert_eq!(stalled_output["status"], "trust_required");
// WorkerRestart resets the worker
let restarted = execute_tool(
"WorkerRestart",
&json!({"worker_id": worker_id}),
)
.expect("WorkerRestart should succeed");
let restarted = execute_tool("WorkerRestart", &json!({"worker_id": worker_id}))
.expect("WorkerRestart should succeed");
let restarted_output: serde_json::Value = serde_json::from_str(&restarted).expect("json");
assert_eq!(
restarted_output["status"], "spawning",
"restarted worker should be back at spawning"
);
assert_eq!(restarted_output["trust_gate_cleared"], false,
assert_eq!(
restarted_output["trust_gate_cleared"], false,
"restart clears trust — next observe loop must re-acquire trust"
);
}