xcodeai 2.1.0

Autonomous AI coding agent — zero human intervention, sbox sandboxed, OpenAI-compatible
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228

mod helpers;
/// End-to-end integration tests for the `xcode` binary.
///
/// Each test:
///   1. Starts a mock OpenAI-compatible SSE server (see `mock_llm_server`).
///   2. Invokes the `xcode` binary with `--no-sandbox` and `--provider-url`
///      pointing at the mock server.
///   3. Asserts the expected outcome (exit code, files created, session recorded).
mod mock_llm_server;

use helpers::{assert_file_contains, output_to_string, run_xcode_with_env};
use mock_llm_server::{start_mock_server, MockScenario};
use tempfile::TempDir;

/// Helper: common provider args for a mock server at `addr`.
#[allow(dead_code)] // useful test helper, not all tests use it
fn provider_args(addr: std::net::SocketAddr) -> [String; 4] {
    [
        "--no-sandbox".to_string(),
        "--provider-url".to_string(),
        format!("http://127.0.0.1:{}/v1", addr.port()),
        "--api-key".to_string(),
    ]
}

// ─── test_run_simple_text_response ─────────────────────────────────────────

/// `xcode run` with a mock that returns plain text should exit 0.
#[tokio::test]
async fn test_run_simple_text_response() {
    let (addr, _state) = start_mock_server(vec![MockScenario::TextResponse(
        "Task completed successfully.".to_string(),
    )])
    .await;

    let project_dir = TempDir::new().unwrap();
    let home_dir = TempDir::new().unwrap();

    let port = addr.port().to_string();
    let project_path = project_dir.path().to_str().unwrap().to_string();
    let home_path = home_dir.path().to_str().unwrap().to_string();

    let output = run_xcode_with_env(
        &[
            "run",
            "--no-sandbox",
            "--provider-url",
            &format!("http://127.0.0.1:{}/v1", port),
            "--api-key",
            "testkey",
            "--project",
            &project_path,
            "hello",
        ],
        &[("HOME", &home_path)],
    )
    .await;

    let text = output_to_string(&output);
    assert!(
        output.status.success(),
        "xcode run failed (exit {:?}).\nOutput:\n{}",
        output.status.code(),
        text
    );
}

// ─── test_run_creates_file_via_tool_call ────────────────────────────────────

/// `xcode run` with a mock that returns a `file_write` tool call should
/// create the specified file in the project directory.
#[tokio::test]
async fn test_run_creates_file_via_tool_call() {
    let (addr, _state) = start_mock_server(vec![MockScenario::ToolCallResponse {
        name: "file_write".to_string(),
        args: r#"{"path":"hello.txt","content":"Hello World"}"#.to_string(),
        final_text: "Done".to_string(),
    }])
    .await;

    let project_dir = TempDir::new().unwrap();
    let home_dir = TempDir::new().unwrap();

    let port = addr.port().to_string();
    let project_path = project_dir.path().to_str().unwrap().to_string();
    let home_path = home_dir.path().to_str().unwrap().to_string();

    let output = run_xcode_with_env(
        &[
            "run",
            "--no-sandbox",
            "--provider-url",
            &format!("http://127.0.0.1:{}/v1", port),
            "--api-key",
            "testkey",
            "--project",
            &project_path,
            "create hello.txt",
        ],
        &[("HOME", &home_path)],
    )
    .await;

    let text = output_to_string(&output);
    assert!(
        output.status.success(),
        "xcode run failed (exit {:?}).\nOutput:\n{}",
        output.status.code(),
        text
    );

    let expected_file = project_dir.path().join("hello.txt");
    assert!(
        expected_file.exists(),
        "Expected file {:?} was not created.\nxcode output:\n{}",
        expected_file,
        text
    );
    assert_file_contains(&expected_file, "Hello World");
}

// ─── test_run_handles_llm_error ─────────────────────────────────────────────

/// When the LLM returns HTTP 500 the `xcode` binary should exit non-zero
/// with a user-friendly error message (not a panic/stack trace).
#[tokio::test]
async fn test_run_handles_llm_error() {
    // One 500 error is enough — we set XCODEAI_RETRY_MAX=0 so retries are
    // disabled and the error propagates immediately.
    let (addr, _state) = start_mock_server(vec![MockScenario::ErrorResponse(500)]).await;

    let project_dir = TempDir::new().unwrap();
    let home_dir = TempDir::new().unwrap();

    let port = addr.port().to_string();
    let project_path = project_dir.path().to_str().unwrap().to_string();
    let home_path = home_dir.path().to_str().unwrap().to_string();

    let output = run_xcode_with_env(
        &[
            "run",
            "--no-sandbox",
            "--provider-url",
            &format!("http://127.0.0.1:{}/v1", port),
            "--api-key",
            "testkey",
            "--project",
            &project_path,
            "test error handling",
        ],
        // Disable retries so the 500 error propagates immediately (no sleeps).
        &[("HOME", &home_path), ("XCODEAI_RETRY_MAX", "0")],
    )
    .await;

    assert!(
        !output.status.success(),
        "Expected non-zero exit code on LLM error, but got success.\nOutput:\n{}",
        output_to_string(&output)
    );

    // Must NOT be a Rust panic.
    let combined = output_to_string(&output);
    assert!(
        !combined.contains("thread 'main' panicked"),
        "Binary panicked instead of returning a graceful error.\nOutput:\n{}",
        combined
    );
}

// ─── test_session_persisted_after_run ───────────────────────────────────────

/// After a successful `xcode run`, `xcode session list` should show the
/// newly created session (not "No sessions found").
#[tokio::test]
async fn test_session_persisted_after_run() {
    let (addr, _state) = start_mock_server(vec![MockScenario::TextResponse(
        "Persisted successfully.".to_string(),
    )])
    .await;

    // Isolate the SQLite database by redirecting HOME.
    let home_dir = TempDir::new().unwrap();
    let project_dir = TempDir::new().unwrap();

    let port = addr.port().to_string();
    let project_path = project_dir.path().to_str().unwrap().to_string();
    let home_path = home_dir.path().to_str().unwrap().to_string();

    // Run xcode — this should create a session in the DB.
    let run_output = run_xcode_with_env(
        &[
            "run",
            "--no-sandbox",
            "--provider-url",
            &format!("http://127.0.0.1:{}/v1", port),
            "--api-key",
            "testkey",
            "--project",
            &project_path,
            "persist this session",
        ],
        &[("HOME", &home_path)],
    )
    .await;

    assert!(
        run_output.status.success(),
        "xcode run failed.\nOutput:\n{}",
        output_to_string(&run_output)
    );

    // Now list sessions — should NOT be empty.
    let list_output = run_xcode_with_env(&["session", "list"], &[("HOME", &home_path)]).await;

    assert!(
        list_output.status.success(),
        "xcode session list failed.\nOutput:\n{}",
        output_to_string(&list_output)
    );

    let list_text = output_to_string(&list_output);
    assert!(
        !list_text.contains("No sessions found"),
        "Expected at least one session after run, but got:\n{}",
        list_text
    );
}