car-ffi-common 0.24.0

Shared logic for FFI bindings (NAPI, PyO3) — JSON wrappers for verify, multi-agent, scheduler
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

//! Proxies for the daemon's `coder.*` namespace (built-in coding agent).
//!
//! Unlike the in-process `supervisor`/`external_agents` modules, coder
//! sessions live **in the daemon** — they must be visible to CarHost and
//! survive the FFI caller's process — so every function here is a thin
//! [`DaemonClient`] call with the exact WS wire shapes. Streaming
//! (`coder.subscribe` / `coder.event`) is WebSocket-only; FFI callers that
//! want live events connect to the daemon's WS directly (same contract as
//! `infer_stream`).

use serde_json::{json, Value};

use crate::proxy::DaemonClient;

fn to_string(v: Value) -> Result<String, String> {
    serde_json::to_string(&v).map_err(|e| e.to_string())
}

/// `coder.start` — provision a worktree, derive the outcome contract.
/// `engine` is `auto | native | external[:agent_id]` (None = auto).
pub async fn start(
    client: &DaemonClient,
    repo: &str,
    intent: &str,
    engine: Option<&str>,
    max_iterations: Option<u32>,
) -> Result<String, String> {
    let mut params = json!({ "repo": repo, "intent": intent });
    if let Some(engine) = engine {
        params["engine"] = json!(engine);
    }
    if let Some(n) = max_iterations {
        params["max_iterations"] = json!(n);
    }
    client.call("coder.start", params).await.and_then(to_string)
}

/// `coder.confirm_contract` — accept (or replace with `contract_json`) the
/// proposed contract and start the work loop.
pub async fn confirm_contract(
    client: &DaemonClient,
    session_id: &str,
    contract_json: Option<&str>,
) -> Result<String, String> {
    let mut params = json!({ "session_id": session_id });
    if let Some(contract) = contract_json {
        params["contract"] = serde_json::from_str(contract)
            .map_err(|e| format!("invalid contract JSON: {e}"))?;
    }
    client
        .call("coder.confirm_contract", params)
        .await
        .and_then(to_string)
}

/// `coder.list` — all sessions (live + persisted), newest first.
pub async fn list(client: &DaemonClient) -> Result<String, String> {
    client.call("coder.list", json!({})).await.and_then(to_string)
}

/// `coder.get` — full session detail.
pub async fn get(client: &DaemonClient, session_id: &str) -> Result<String, String> {
    client
        .call("coder.get", json!({ "session_id": session_id }))
        .await
        .and_then(to_string)
}

/// `coder.respond` — answer a `user_input_requested` event (reserved).
pub async fn respond(
    client: &DaemonClient,
    session_id: &str,
    text: &str,
) -> Result<String, String> {
    client
        .call("coder.respond", json!({ "session_id": session_id, "text": text }))
        .await
        .and_then(to_string)
}

/// `coder.approve_merge` — approve publishes the `car/coder/<id>` branch;
/// deny abandons the session.
pub async fn approve_merge(
    client: &DaemonClient,
    session_id: &str,
    approve: bool,
) -> Result<String, String> {
    client
        .call(
            "coder.approve_merge",
            json!({ "session_id": session_id, "approve": approve }),
        )
        .await
        .and_then(to_string)
}

/// `coder.cancel` — stop the loop, abandon the session, clean the worktree.
pub async fn cancel(client: &DaemonClient, session_id: &str) -> Result<String, String> {
    client
        .call("coder.cancel", json!({ "session_id": session_id }))
        .await
        .and_then(to_string)
}