orchflow-terminal 0.1.0

High-performance terminal I/O management with PTY support, buffering, and stream processing
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

//! IPC abstraction layer for terminal communication
//!
//! This trait allows OrchFlow to work with any transport mechanism.

use crate::protocol::{ControlMessage, TerminalInput};
use crate::pty_manager::PtyHandle;
use async_trait::async_trait;

/// Trait for IPC communication channels
#[async_trait]
pub trait IpcChannel: Send + Sync {
    /// Start streaming terminal output
    async fn start_streaming(
        &self,
        terminal_id: String,
        pty_handle: PtyHandle,
    ) -> Result<(), Box<dyn std::error::Error>>;

    /// Send input to terminal
    async fn send_input(
        &self,
        terminal_id: &str,
        input: TerminalInput,
    ) -> Result<(), Box<dyn std::error::Error>>;

    /// Send control message
    async fn send_control(
        &self,
        terminal_id: &str,
        message: ControlMessage,
    ) -> Result<(), Box<dyn std::error::Error>>;

    /// Stop streaming
    async fn stop_streaming(&self, terminal_id: &str) -> Result<(), Box<dyn std::error::Error>>;
}

/// Direct in-process channel (no IPC overhead)
pub struct DirectChannel;

#[async_trait]
impl IpcChannel for DirectChannel {
    async fn start_streaming(
        &self,
        _terminal_id: String,
        _pty_handle: PtyHandle,
    ) -> Result<(), Box<dyn std::error::Error>> {
        // In direct mode, the caller handles streaming
        Ok(())
    }

    async fn send_input(
        &self,
        _terminal_id: &str,
        _input: TerminalInput,
    ) -> Result<(), Box<dyn std::error::Error>> {
        // In direct mode, input is handled directly
        Ok(())
    }

    async fn send_control(
        &self,
        _terminal_id: &str,
        _message: ControlMessage,
    ) -> Result<(), Box<dyn std::error::Error>> {
        // In direct mode, control is handled directly
        Ok(())
    }

    async fn stop_streaming(&self, _terminal_id: &str) -> Result<(), Box<dyn std::error::Error>> {
        // In direct mode, nothing to stop
        Ok(())
    }
}