Please address the comments from this code review:

## Overall Comments
- In `should_resolve_child_exec_from_cwd`, you iterate over `path.components()` twice (`count()` then `next()`), which reconstructs the iterator; consider capturing the first component once and basing both the “single component” and “has directory hierarchy” checks on that to simplify the logic and avoid repeated work.
- For bare command names that should go through PATH (e.g. `python`), `resolve_child_exec_path` still runs them through `normalize_path`; if `normalize_path` performs filesystem-style normalization, you might want to bypass it for non-path-like bare commands to avoid unexpected transformations on command names.

Please address the comments from this code review:

## Overall Comments
- The logic to determine whether `child_exec` is a bare command vs. a path is duplicated in both `should_resolve_child_exec_from_cwd` and `resolve_child_exec_path`; consider extracting a small helper (e.g., `is_bare_command(child_exec: &str) -> bool`) to make this behavior easier to reason about and keep consistent.
- Right now an empty `child_exec` string would be treated as a relative path and effectively resolve to `cwd`; consider explicitly handling the empty-string case (e.g., returning an error earlier) to avoid unintentionally executing the working directory.

## Individual Comments

### Comment 1
<location path="src-tauri/src/commands/maa_agent.rs" line_range="60-67" />
<code_context>
+/// - `python` / `node` 这类裸命令名：交给系统 PATH 查找，不拼接 cwd。
+/// - `./agent.py` / `../bin/tool` / `subdir/tool`：视为相对路径，拼接 cwd。
+/// - 绝对路径或带盘符前缀路径：按原值使用。
+fn should_resolve_child_exec_from_cwd(child_exec: &str) -> bool {
+    let path = Path::new(child_exec);
+    let mut components = path.components();
+    let first = components.next();
+    let second = components.next();
+
+    // 裸命令名（无目录层级）不应拼接 cwd
+    if first.is_some() && second.is_none() {
+        return matches!(first, Some(Component::CurDir | Component::ParentDir));
+    }
</code_context>
<issue_to_address>
**suggestion:** The “bare command” detection is duplicated and split across two functions, which could drift over time.

Both `should_resolve_child_exec_from_cwd` and `resolve_child_exec_path` re-derive the first two path components and each redefines the "bare command" check (`first.is_some() && second.is_none()` vs `matches!(first, Some(Component::Normal(_)))`). Consider extracting a shared helper like `fn is_bare_command(path: &Path) -> bool` and using it in both places to avoid duplication and keep the criteria consistent.

Suggested implementation:

```rust
use std::sync::{Arc, Mutex};
use std::thread;
use std::path::{Path, Component};
    ANSI_RE.replace_all(s, "").into_owned()
}

/// 判断给定路径是否是“裸命令名”, 即仅包含单个普通组件（无目录层级或前缀）。
///
/// 例如:
/// - `python` / `node` / `git`    -> 裸命令, 返回 true
/// - `./agent.py` / `../bin/tool` -> 非裸命令, 返回 false
/// - `subdir/tool`                -> 非裸命令, 返回 false
/// - 绝对路径或带盘符前缀路径     -> 非裸命令, 返回 false
fn is_bare_command(path: &Path) -> bool {
    let mut components = path.components();
    matches!(components.next(), Some(Component::Normal(_))) && components.next().is_none()
}

/// 判断 child_exec 是否应当作为相对路径（基于 cwd）解析。
///
/// - `python` / `node` 这类裸命令名：交给系统 PATH 查找，不拼接 cwd。
/// - `./agent.py` / `../bin/tool` / `subdir/tool`：视为相对路径，拼接 cwd。
/// - 绝对路径或带盘符前缀路径：按原值使用。
fn should_resolve_child_exec_from_cwd(child_exec: &str) -> bool {
    let path = Path::new(child_exec);

    // 裸命令交给 PATH 处理, 不拼接 cwd
    if is_bare_command(path) {
        return false;
    }

    let mut components = path.components();
    let first = components.next();

    match first {
        // 显式相对路径: ./xxx 或 ../xxx -> 基于 cwd 解析
        Some(Component::CurDir) | Some(Component::ParentDir) => true,
        // 绝对路径或带盘符前缀路径: 按原值使用, 不拼接 cwd
        Some(Component::Prefix(_)) | Some(Component::RootDir) => false,
        // 形如 `subdir/tool` 的相对路径: 基于 cwd 解析
        Some(Component::Normal(_)) => true,
        // 空字符串等情况: 保守起见不拼接 cwd
        None => false,
    }

```

There is another function `resolve_child_exec_path` in this file that currently re-derives the "bare command" logic by manually inspecting the first path components (e.g. via `first.is_some() && second.is_none()` or `matches!(first, Some(Component::Normal(_)))`). To fully apply the refactor and avoid duplication, update that function to use the new helper:

1. Replace its inline "bare command" checks with `if is_bare_command(&path) { ... }`.
2. Remove any duplicated `components.next()` / `first` / `second` handling that only exists to distinguish bare commands from other paths.

This will keep the criteria for bare commands centralized in `is_bare_command` and prevent them from drifting between the two functions.
</issue_to_address>

### Comment 2
<location path="src-tauri/src/commands/maa_agent.rs" line_range="61-70" />
<code_context>
+/// - `./agent.py` / `../bin/tool` / `subdir/tool`：视为相对路径，拼接 cwd。
+/// - 绝对路径或带盘符前缀路径：按原值使用。
+fn should_resolve_child_exec_from_cwd(child_exec: &str) -> bool {
+    let path = Path::new(child_exec);
+    let mut components = path.components();
+    let first = components.next();
+    let second = components.next();
+
+    // 裸命令名（无目录层级）不应拼接 cwd
+    if first.is_some() && second.is_none() {
+        return matches!(first, Some(Component::CurDir | Component::ParentDir));
+    }
+
+    if path.is_absolute() {
+        return false;
+    }
+
+    // Windows 盘符前缀（如 C:python.exe / C:\Python\python.exe）不拼接 cwd
+    if matches!(first, Some(Component::Prefix(_))) {
+        return false;
+    }
+
+    true
+}
+
</code_context>
<issue_to_address>
**question:** Empty or whitespace-only `child_exec` will be treated as a relative path and effectively resolve to `cwd`, which might be surprising.

For an empty `child_exec`, `components()` yields nothing, so the bare-command branch is skipped, `path.is_absolute()` is false, and the prefix check is skipped. The function then returns `true`, so `resolve_child_exec_path` effectively resolves `""` to `cwd`. If `child_exec` can be empty or otherwise invalid, consider explicitly rejecting or bypassing resolution instead of implicitly mapping it to `cwd`.
</issue_to_address>

Please address the comments from this code review:

## Overall Comments
- In `resolve_child_exec_path` and `should_resolve_child_exec_from_cwd` you both parse `child_exec` into a `Path` and call `is_bare_command`, which is slightly redundant; consider consolidating the logic so `child_exec` is parsed and classified (bare/relative/absolute/prefixed) in one place and reused to simplify the control flow.