codex-mobile-bridge 0.2.6

Remote bridge and service manager for codex-mobile.
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

use serde::{Deserialize, Serialize};

use super::helpers::now_millis;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ApiError {
    pub code: String,
    pub message: String,
}

impl ApiError {
    pub fn new(code: impl Into<String>, message: impl Into<String>) -> Self {
        Self {
            code: code.into(),
            message: message.into(),
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RuntimeRecord {
    pub runtime_id: String,
    pub display_name: String,
    pub codex_home: Option<String>,
    pub codex_binary: String,
    pub is_primary: bool,
    pub auto_start: bool,
    pub created_at_ms: i64,
    pub updated_at_ms: i64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AppServerHandshakeSummary {
    pub state: String,
    pub protocol: String,
    pub transport: String,
    pub experimental_api_enabled: bool,
    pub notification_mode: String,
    #[serde(default)]
    pub opt_out_notification_methods: Vec<String>,
    pub detail: Option<String>,
    pub updated_at_ms: i64,
}

impl Default for AppServerHandshakeSummary {
    fn default() -> Self {
        Self::inactive()
    }
}

impl AppServerHandshakeSummary {
    pub fn new(
        state: impl Into<String>,
        experimental_api_enabled: bool,
        opt_out_notification_methods: Vec<String>,
        detail: Option<String>,
    ) -> Self {
        let notification_mode = if opt_out_notification_methods.is_empty() {
            "full".to_string()
        } else {
            "optimized".to_string()
        };
        Self {
            state: state.into(),
            protocol: "jsonrpc2.0".to_string(),
            transport: "stdio".to_string(),
            experimental_api_enabled,
            notification_mode,
            opt_out_notification_methods,
            detail,
            updated_at_ms: now_millis(),
        }
    }

    pub fn inactive() -> Self {
        Self::new("inactive", false, Vec::new(), None)
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RuntimeStatusSnapshot {
    pub runtime_id: String,
    pub status: String,
    pub codex_home: Option<String>,
    pub user_agent: Option<String>,
    pub platform_family: Option<String>,
    pub platform_os: Option<String>,
    pub last_error: Option<String>,
    pub pid: Option<u32>,
    #[serde(default)]
    pub app_server_handshake: AppServerHandshakeSummary,
    pub updated_at_ms: i64,
}

impl RuntimeStatusSnapshot {
    pub fn stopped(runtime_id: impl Into<String>) -> Self {
        Self {
            runtime_id: runtime_id.into(),
            status: "stopped".to_string(),
            codex_home: None,
            user_agent: None,
            platform_family: None,
            platform_os: None,
            last_error: None,
            pid: None,
            app_server_handshake: AppServerHandshakeSummary::inactive(),
            updated_at_ms: now_millis(),
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RuntimeSummary {
    pub runtime_id: String,
    pub display_name: String,
    pub codex_home: Option<String>,
    pub codex_binary: String,
    pub is_primary: bool,
    pub auto_start: bool,
    pub created_at_ms: i64,
    pub updated_at_ms: i64,
    pub status: RuntimeStatusSnapshot,
}

impl RuntimeSummary {
    pub fn from_parts(record: &RuntimeRecord, status: RuntimeStatusSnapshot) -> Self {
        Self {
            runtime_id: record.runtime_id.clone(),
            display_name: record.display_name.clone(),
            codex_home: record.codex_home.clone(),
            codex_binary: record.codex_binary.clone(),
            is_primary: record.is_primary,
            auto_start: record.auto_start,
            created_at_ms: record.created_at_ms,
            updated_at_ms: record.updated_at_ms,
            status,
        }
    }
}