dpc-tau-cli 0.2.0

A minimal Unix-first coding agent.
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

use std::io as path_std_io;

use tau_proto::{Event, EventName, EventSelector, HarnessInputMessage, HarnessOutputMessage};

use crate::CliError;
use crate::daemon::DaemonHandle;
use crate::ui_client::{UiInputReader, UiOutputWriter};

pub(crate) enum RenderResponse<T> {
    Ignore,
    Matched(Result<T, CliError>),
}

pub(crate) fn request_rendered_value<T>(
    daemon: &mut DaemonHandle,
    client_name: &'static str,
    request_id_prefix: &str,
    build_request: impl FnOnce(String) -> HarnessInputMessage,
    handle_result: impl FnMut(HarnessOutputMessage, &str) -> RenderResponse<T>,
) -> Result<T, CliError> {
    request_rendered_value_with_selectors(
        daemon,
        client_name,
        request_id_prefix,
        Vec::new(),
        build_request,
        handle_result,
    )
}

/// Runs one rendered preview while subscribing to additional snapshot events.
pub(crate) fn request_rendered_value_with_selectors<T>(
    daemon: &mut DaemonHandle,
    client_name: &'static str,
    request_id_prefix: &str,
    additional_selectors: Vec<EventSelector>,
    build_request: impl FnOnce(String) -> HarnessInputMessage,
    mut handle_result: impl FnMut(HarnessOutputMessage, &str) -> RenderResponse<T>,
) -> Result<T, CliError> {
    let (mut reader, mut writer) =
        connect_render_client(daemon, client_name, additional_selectors)?;
    let result = (|| {
        wait_for_preview_session(&mut reader)?;
        let request_id = crate::ui_client::next_request_id(request_id_prefix);
        crate::ui_client::send_message(&mut writer, &build_request(request_id.clone()))?;

        loop {
            let Some(message) = reader.read_message().map_err(path_std_io::Error::other)? else {
                return Err(CliError::Participant("daemon disconnected".to_owned()));
            };
            match message {
                HarnessOutputMessage::Disconnect(disconnect) => {
                    return Err(CliError::Participant(
                        disconnect
                            .reason
                            .unwrap_or_else(|| "daemon disconnected".to_owned()),
                    ));
                }
                message => match handle_result(message, &request_id) {
                    RenderResponse::Ignore => {}
                    RenderResponse::Matched(result) => return result,
                },
            }
        }
    })();
    // Render diagnostics own a private one-shot daemon. Terminate that daemon
    // explicitly; ordinary UI disconnect no longer controls session lifetime.
    let _ = crate::ui_client::send_message(
        &mut writer,
        &HarnessInputMessage::UiShutdownRequest(tau_proto::UiShutdownRequest {}),
    );
    disconnect_render_client(&mut writer);
    result
}

fn connect_render_client(
    daemon: &mut DaemonHandle,
    client_name: &'static str,
    mut additional_selectors: Vec<EventSelector>,
) -> Result<(UiInputReader, UiOutputWriter), CliError> {
    let (reader, mut writer) =
        crate::ui_client::connect_daemon_ui_client(daemon, client_name, None)?;
    additional_selectors.push(EventSelector::Exact(EventName::SESSION_REPLAY_COMPLETE));
    crate::ui_client::subscribe(&mut writer, additional_selectors)?;
    Ok((reader, writer))
}

/// Waits for the per-client catch-up boundary emitted after eager session
/// initialization, so previews include the stable extension context surface.
fn wait_for_preview_session(reader: &mut UiInputReader) -> Result<(), CliError> {
    loop {
        let Some(message) = reader.read_message().map_err(path_std_io::Error::other)? else {
            return Err(CliError::Participant("daemon disconnected".to_owned()));
        };
        match message {
            HarnessOutputMessage::Deliver(delivery) => {
                if let Event::SessionReplayComplete(complete) = *delivery.event {
                    if let Some(error) = complete.error {
                        return Err(CliError::Participant(format!(
                            "preview session `{}` failed to initialize: {error}",
                            complete.session_id
                        )));
                    }
                    return Ok(());
                }
            }
            HarnessOutputMessage::Disconnect(disconnect) => {
                return Err(CliError::Participant(
                    disconnect
                        .reason
                        .unwrap_or_else(|| "daemon disconnected".to_owned()),
                ));
            }
            _ => {}
        }
    }
}

fn disconnect_render_client(writer: &mut UiOutputWriter) {
    let _ = crate::ui_client::send_message(
        writer,
        &HarnessInputMessage::Disconnect(tau_proto::Disconnect {
            reason: Some("done".to_owned()),
        }),
    );
}