Skip to main content

byob_protocol/
workspace.rs

1//! Workspaces as clients see them, layered settings (global → workspace → chat), and the
2//! engine's folder browser for picking a workspace folder from a browser.
3//!
4//! The settings types and their resolver live in [`byob_types::config`], so the engine and
5//! the UI resolve the same way.
6
7use serde::{Deserialize, Serialize};
8
9pub use byob_types::config::{Approvals, Effective, EnvKind, Field, Layer, Level, Sourced, ToolMode};
10
11use crate::{ClientMsg, Link};
12
13/// Longest id (chat, workspace) a client may send.
14pub const MAX_ID_CHARS: usize = 128;
15/// Longest workspace name a client may send (the engine trims it to 80 characters).
16pub const MAX_NAME_CHARS: usize = 200;
17/// Longest folder path a client may send.
18pub const MAX_PATH_CHARS: usize = 4096;
19/// Most folders listed by one [`ServerMsg::Folders`](crate::ServerMsg::Folders).
20pub const MAX_LISTED_FOLDERS: usize = 500;
21
22/// A workspace in the chat list.
23#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
24pub struct WorkspaceSummary {
25    pub id: String,
26    pub name: String,
27    /// Its folder on the engine's machine.
28    pub folder: String,
29    /// How many chats it has.
30    #[serde(default)]
31    pub chats: u64,
32    /// Latest activity of its chats, else when it was created (ms since the epoch).
33    #[serde(default)]
34    pub updated_at: i64,
35    /// Its environment setting, for a small marker in the list.
36    #[serde(default)]
37    pub env: EnvKind,
38}
39
40/// Which level's settings a [`ClientMsg::GetConfig`] / [`ClientMsg::SetConfig`] means.
41#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
42#[serde(tag = "kind", rename_all = "snake_case")]
43pub enum ConfigScope {
44    /// `settings.json` (the endpoint itself changes with [`ClientMsg::SetInference`]).
45    Global,
46    Workspace {
47        id: String,
48    },
49    /// The chat this client looks at, or the new chat it is about to start.
50    Chat,
51}
52
53/// One level's settings, what applies there, and where each value comes from.
54#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
55pub struct ConfigView {
56    pub scope: ConfigScope,
57    /// What this level sets itself.
58    pub own: Layer,
59    /// What applies at this level (to the chat, or to new chats of the workspace).
60    pub effective: Effective,
61    /// This level stores its own API key (the key itself never leaves the engine).
62    #[serde(default)]
63    pub has_key: bool,
64    /// For the heading: the workspace's or chat's name.
65    #[serde(default)]
66    pub title: String,
67    /// The workspace this level belongs to (none for global).
68    #[serde(default)]
69    pub workspace: Option<WorkspaceSummary>,
70}
71
72/// Where a new workspace's folder comes from.
73#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
74#[serde(tag = "kind", rename_all = "snake_case")]
75pub enum NewFolder {
76    /// A folder that exists on the engine's machine.
77    Existing { path: String },
78    /// A fresh folder named after the workspace, in the workspaces folder (settings.json
79    /// `workspaces_root`, default `~/byob-workspaces`).
80    Create,
81}
82
83/// A folder's subfolders on the engine's machine (answer to [`ClientMsg::ListFolders`]).
84#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
85pub struct FolderList {
86    /// The folder listed (absolute, canonical).
87    pub path: String,
88    #[serde(default)]
89    pub parent: Option<String>,
90    /// Names of its subfolders (hidden ones left out), sorted, at most [`MAX_LISTED_FOLDERS`].
91    #[serde(default)]
92    pub dirs: Vec<String>,
93    /// More subfolders than listed.
94    #[serde(default)]
95    pub truncated: bool,
96    /// Why it couldn't be listed (`path` is then what was asked for).
97    #[serde(default)]
98    pub error: Option<String>,
99}
100
101/// The endpoint of the chat in view, when its workspace or the chat itself picked another
102/// one than the global settings.
103#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
104pub struct ChatEndpoint {
105    pub base_url: String,
106    pub model: String,
107    /// Which level chose it.
108    pub from: Level,
109    pub has_api_key: bool,
110    #[serde(default)]
111    pub link: Link,
112    #[serde(default)]
113    pub info: Option<crate::EndpointInfo>,
114}
115
116fn long(s: &str, max: usize) -> bool {
117    s.chars().count() > max
118}
119
120impl ClientMsg {
121    /// Cheap checks of an untrusted message's sizes (the engine checks meaning: unknown
122    /// ids, folders that don't exist, settings that don't belong at a level).
123    pub fn check_sizes(&self) -> Result<(), String> {
124        let id = |s: &str| if long(s, MAX_ID_CHARS) || s.is_empty() { Err("bad id".to_owned()) } else { Ok(()) };
125        let name = |s: &str| if long(s, MAX_NAME_CHARS) { Err("the name is too long".to_owned()) } else { Ok(()) };
126        let path = |s: &str| if long(s, MAX_PATH_CHARS) { Err("the path is too long".to_owned()) } else { Ok(()) };
127        match self {
128            Self::NewChat { workspace: Some(w) } => id(w),
129            Self::CreateWorkspace { name: n, folder, .. } => {
130                name(n)?;
131                match folder {
132                    NewFolder::Existing { path: p } => path(p),
133                    NewFolder::Create => Ok(()),
134                }
135            }
136            Self::RenameWorkspace { id: i, name: n } => id(i).and_then(|()| name(n)),
137            Self::RemoveWorkspace { id: i, .. } => id(i),
138            Self::GetConfig { scope: ConfigScope::Workspace { id: i } } | Self::SetConfig { scope: ConfigScope::Workspace { id: i }, .. } => id(i),
139            Self::ListFolders { path: Some(p) } => path(p),
140            Self::WorkspaceEnv { workspace: Some(w), .. } => id(w),
141            Self::SetPluginEnabled { .. } | Self::SetPluginSetting { .. } | Self::KeepPlugin { .. } | Self::RemovePlugin { .. } | Self::TrustPlugins { .. } => {
142                crate::plugins::check_sizes(self)
143            }
144            Self::Hello { client, caps, .. } => {
145                name(client)?;
146                crate::version::check_caps(caps)
147            }
148            Self::Plugin { plugin, msg } => crate::version::check_plugin_msg(plugin, msg),
149            Self::OpenView { .. } | Self::CloseView { .. } | Self::ViewEvent { .. } => crate::sites::check_sizes(self),
150            Self::WebCall { owner, method, params, .. } => crate::web::check_call(owner, method, params),
151            _ => crate::queue::check_sizes(self),
152        }
153    }
154}
155
156#[cfg(test)]
157mod tests {
158    use super::*;
159    use crate::ServerMsg;
160
161    #[test]
162    fn workspace_messages_round_trip() {
163        let layer = Layer { env: Some(EnvKind::Container), image: Some("python:3-slim".into()), ..Layer::default() };
164        let msgs = vec![
165            ClientMsg::NewChat { workspace: Some("w1".into()) },
166            ClientMsg::CreateWorkspace { name: "Data".into(), folder: NewFolder::Create, config: layer.clone() },
167            ClientMsg::CreateWorkspace { name: "Repo".into(), folder: NewFolder::Existing { path: "/home/me/repo".into() }, config: Layer::default() },
168            ClientMsg::RenameWorkspace { id: "w1".into(), name: "New".into() },
169            ClientMsg::RemoveWorkspace { id: "w1".into(), clean: true },
170            ClientMsg::GetConfig { scope: ConfigScope::Chat },
171            ClientMsg::SetConfig { scope: ConfigScope::Workspace { id: "w1".into() }, layer: layer.clone(), api_key: None },
172            ClientMsg::ListFolders { path: None },
173            ClientMsg::CheckContainers,
174            ClientMsg::WorkspaceEnv { action: None, workspace: Some("w1".into()) },
175        ];
176        for m in msgs {
177            assert_eq!(ClientMsg::from_json(&m.to_json()).unwrap(), m, "{}", m.to_json());
178            assert!(m.check_sizes().is_ok());
179        }
180        // Older clients' messages still parse.
181        assert_eq!(ClientMsg::from_json(r#"{"type":"new_chat"}"#).unwrap(), ClientMsg::NewChat { workspace: None });
182        assert_eq!(ClientMsg::from_json(r#"{"type":"workspace_env"}"#).unwrap(), ClientMsg::WorkspaceEnv { action: None, workspace: None });
183        let ws = WorkspaceSummary { id: "w1".into(), name: "Data".into(), folder: "/d".into(), chats: 2, updated_at: 5, env: EnvKind::Nix };
184        let effective = byob_types::config::resolve(Default::default(), Default::default(), Default::default());
185        let view = ConfigView { scope: ConfigScope::Global, own: layer, effective, has_key: false, title: "Defaults".into(), workspace: Some(ws.clone()) };
186        let msgs = vec![
187            ServerMsg::Workspaces { items: vec![ws], current: Some("w1".into()), root: "/home/me/byob-workspaces".into(), support: Default::default() },
188            ServerMsg::Config(Box::new(view)),
189            ServerMsg::Folders(FolderList { path: "/".into(), parent: None, dirs: vec!["home".into()], truncated: false, error: None }),
190            ServerMsg::ContainersChecked { ok: false, message: "Docker isn't running".into() },
191            ServerMsg::WorkspaceCreated { id: None, error: Some("no".into()) },
192            ServerMsg::ChatOpened { chat: None, workspace: Some("w1".into()) },
193        ];
194        for m in msgs {
195            assert_eq!(ServerMsg::from_json(&m.to_json()).unwrap(), m);
196        }
197        assert_eq!(ServerMsg::from_json(r#"{"type":"chat_opened","chat":null}"#).unwrap(), ServerMsg::ChatOpened { chat: None, workspace: None });
198    }
199
200    #[test]
201    fn oversized_fields_are_refused() {
202        let huge = "x".repeat(MAX_PATH_CHARS + 1);
203        for m in [
204            ClientMsg::CreateWorkspace { name: "n".into(), folder: NewFolder::Existing { path: huge.clone() }, config: Layer::default() },
205            ClientMsg::CreateWorkspace { name: huge.clone(), folder: NewFolder::Create, config: Layer::default() },
206            ClientMsg::RenameWorkspace { id: huge.clone(), name: "n".into() },
207            ClientMsg::RemoveWorkspace { id: String::new(), clean: false },
208            ClientMsg::ListFolders { path: Some(huge.clone()) },
209            ClientMsg::NewChat { workspace: Some(huge.clone()) },
210            ClientMsg::GetConfig { scope: ConfigScope::Workspace { id: huge.clone() } },
211        ] {
212            assert!(m.check_sizes().is_err(), "{m:?}");
213        }
214    }
215}