magi-code 0.77.1

Repository-aware CLI coding agent for terminal work
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use super::support::*;

#[test]
fn resolve_child_cwd_allows_absolute_by_default_and_false_rejects_outside() {
    let parent = tempfile::TempDir::new().unwrap();
    let outside = tempfile::TempDir::new().unwrap();

    let allowed = resolve_child_cwd(parent.path(), Some(outside.path()), true).unwrap();
    assert_eq!(allowed, outside.path().canonicalize().unwrap());

    let absolute_err = resolve_child_cwd(parent.path(), Some(outside.path()), false)
        .unwrap_err()
        .to_string();
    assert!(absolute_err.contains("tools.subagents.absolute_paths"));

    let relative_err = resolve_child_cwd(parent.path(), Some(Path::new("..")), true)
        .unwrap_err()
        .to_string();
    assert!(relative_err.contains("escapes parent cwd"));
}

#[test]
fn child_cwd_write_stays_inside_requested_child_directory() {
    let temp = tempfile::TempDir::new().unwrap();
    std::fs::create_dir(temp.path().join("child-dir")).unwrap();
    let provider = Arc::new(WritingProvider::new());
    let output = run_subagents(
        SubagentsArgs {
            concurrency: Some(1),
            tasks: vec![SubagentTask {
                intent: "write child file".into(),
                agent: None,
                identity: None,
                context: None,
                cwd: Some(PathBuf::from("child-dir")),
            }],
        },
        config(provider, temp.path()),
    )
    .unwrap();
    let changed_file = temp
        .path()
        .join("child-dir/child.txt")
        .canonicalize()
        .unwrap();
    assert_eq!(
        std::fs::read_to_string(&changed_file).unwrap(),
        "made by child"
    );
    assert_eq!(
        output.results[0].cwd,
        temp.path().join("child-dir").canonicalize().unwrap()
    );
    assert_eq!(output.results[0].changed_files, vec![changed_file]);
}

#[test]
fn resolve_child_cwd_rejects_missing_non_directory_and_symlink_escape() {
    let parent = tempfile::TempDir::new().unwrap();
    let missing = resolve_child_cwd(parent.path(), Some(Path::new("missing")), true)
        .unwrap_err()
        .to_string();
    assert!(
        missing.contains("No such file") || missing.contains("not found"),
        "{missing}"
    );

    std::fs::write(parent.path().join("file-cwd"), "file").unwrap();
    let file_err = resolve_child_cwd(parent.path(), Some(Path::new("file-cwd")), true)
        .unwrap_err()
        .to_string();
    assert!(file_err.contains("not a directory"), "{file_err}");

    #[cfg(unix)]
    {
        use std::os::unix::fs::symlink;
        let outside = tempfile::TempDir::new().unwrap();
        symlink(outside.path(), parent.path().join("escape-link")).unwrap();
        let link_err = resolve_child_cwd(parent.path(), Some(Path::new("escape-link")), true)
            .unwrap_err()
            .to_string();
        assert!(link_err.contains("escapes parent cwd"), "{link_err}");
    }
}

#[test]
fn multiple_child_sessions_are_unique() {
    let temp = tempfile::TempDir::new().unwrap();
    let provider = Arc::new(CountingProvider::new("never"));
    let mut cfg = config(provider, temp.path());
    cfg.sessions_root = Some(temp.path().join("sessions"));
    let output = run_subagents(
        SubagentsArgs {
            concurrency: Some(2),
            tasks: vec![
                SubagentTask {
                    intent: "one".into(),
                    agent: None,
                    identity: None,
                    context: None,
                    cwd: None,
                },
                SubagentTask {
                    intent: "two".into(),
                    agent: None,
                    identity: None,
                    context: None,
                    cwd: None,
                },
            ],
        },
        cfg,
    )
    .unwrap();
    let first = &output.results[0];
    let second = &output.results[1];
    assert!(first.session_id.is_some() && second.session_id.is_some());
    assert_ne!(first.session_id, second.session_id);
    assert_ne!(first.session_path, second.session_path);
    for path in [
        first.session_path.as_ref().unwrap(),
        second.session_path.as_ref().unwrap(),
    ] {
        assert!(path.starts_with(temp.path().join("sessions/subagents")));
        assert!(path.exists());
    }
}