1use crate::agents::AgentRegistry;
4use crate::browser::BrowserService;
5use crate::customization::Customization;
6use crate::debugger::{DebugAdapterConfig, DebugError, DebugResult, DebuggerSession};
7use crate::git::GitService;
8use crate::intelligence::{DevelopmentIntelligence, DevelopmentNode, DevelopmentNodeKind};
9use crate::kernels::KernelManager;
10use crate::lsp::LanguageService;
11use crate::testing::{TestFramework, TestService, TestSuite};
12use crate::tools::{DevelopmentToolContext, DevelopmentToolRouter};
13use glass_browser::browser::session::{KnowledgeStore, default_knowledge_store_path_for_workspace};
14use glass_browser::development::{DevelopmentResult, ProjectWorkspace};
15use std::collections::BTreeMap;
16use std::path::{Path, PathBuf};
17use std::sync::{Arc, Mutex, MutexGuard};
18
19pub struct DevelopmentWorkspace {
25 root: PathBuf,
26 agents: AgentRegistry,
27 browser: BrowserService,
28 customization: Customization,
29 project: ProjectWorkspace,
30 debuggers: BTreeMap<String, DebuggerSession>,
31 git: Option<GitService>,
32 intelligence: DevelopmentIntelligence,
33 kernels: KernelManager,
34 language: LanguageService,
35 knowledge: KnowledgeStore,
36 tests: TestService,
37 tools: DevelopmentToolRouter,
38 generation: u64,
39}
40
41impl DevelopmentWorkspace {
42 pub fn open(root: impl AsRef<Path>) -> DevelopmentResult<Self> {
44 let project = ProjectWorkspace::open(root)?;
45 let root = project.root().to_path_buf();
46 let git = if root
47 .ancestors()
48 .any(|ancestor| ancestor.join(".git").exists())
49 {
50 Some(GitService::open(&root).map_err(|error| {
51 glass_browser::development::DevelopmentError::Process(error.to_string())
52 })?)
53 } else {
54 None
55 };
56 let customization = Customization::load(&root)?;
57 let mut tests = TestService::discover(&root).map_err(|error| {
58 glass_browser::development::DevelopmentError::Process(error.to_string())
59 })?;
60 for (name, configured) in &customization.config().tests {
61 tests
62 .register(TestSuite {
63 id: name.clone(),
64 name: name.clone(),
65 framework: TestFramework::Custom,
66 program: if cfg!(windows) { "cmd" } else { "sh" }.into(),
67 arguments: if cfg!(windows) {
68 vec!["/C".into(), configured.command.clone()]
69 } else {
70 vec!["-lc".into(), configured.command.clone()]
71 },
72 source: customization
73 .config_path()
74 .unwrap_or(root.as_path())
75 .to_path_buf(),
76 })
77 .map_err(|error| {
78 glass_browser::development::DevelopmentError::Process(error.to_string())
79 })?;
80 }
81 let kernels = KernelManager::new(&root).map_err(|error| {
82 glass_browser::development::DevelopmentError::Process(error.to_string())
83 })?;
84 let mut agents = AgentRegistry::new(&root)?;
85 agents.set_additional_system_prompt(customization.agent_instructions())?;
86 agents.set_defaults(
87 customization.config().agent.model.clone(),
88 customization.config().agent.reasoning.clone(),
89 )?;
90 let language = LanguageService::new(&root)?;
91 let browser = BrowserService::new(&root)?;
92 let knowledge = KnowledgeStore::open(default_knowledge_store_path_for_workspace(
93 "default",
94 &root.display().to_string(),
95 Some(1),
96 ))
97 .map_err(|error| {
98 glass_browser::development::DevelopmentError::Process(error.to_string())
99 })?;
100 customization.run_hooks(
101 "workspace.opened",
102 &serde_json::json!({"root":root,"generation":1}),
103 )?;
104 let tools = DevelopmentToolRouter::with_customization(&customization);
105 Ok(Self {
106 root: root.clone(),
107 agents,
108 browser,
109 customization,
110 project,
111 debuggers: BTreeMap::new(),
112 git,
113 intelligence: {
114 let mut intelligence = DevelopmentIntelligence::default();
115 intelligence.upsert_node(DevelopmentNode {
116 id: "repository:root".into(),
117 kind: DevelopmentNodeKind::Repository,
118 label: root.display().to_string(),
119 revision: 0,
120 stale: false,
121 evidence: serde_json::json!({"root":root}),
122 })?;
123 intelligence
124 },
125 kernels,
126 language,
127 knowledge,
128 tests,
129 tools,
130 generation: 1,
131 })
132 }
133
134 pub fn root(&self) -> &Path {
136 &self.root
137 }
138
139 pub fn generation(&self) -> u64 {
141 self.generation
142 }
143
144 pub fn project(&self) -> &ProjectWorkspace {
147 &self.project
148 }
149
150 pub fn project_mut(&mut self) -> &mut ProjectWorkspace {
152 &mut self.project
153 }
154
155 pub fn agents(&mut self) -> &mut AgentRegistry {
156 &mut self.agents
157 }
158
159 pub fn browser(&self) -> &BrowserService {
160 &self.browser
161 }
162
163 pub fn customization(&self) -> &Customization {
164 &self.customization
165 }
166
167 pub fn start_debugger(
169 &mut self,
170 name: &str,
171 config: &DebugAdapterConfig,
172 timeout: std::time::Duration,
173 ) -> DebugResult<()> {
174 validate_service_name(name)?;
175 if self.debuggers.contains_key(name) {
176 return Err(DebugError::InvalidInput(format!(
177 "debugger session {name} already exists"
178 )));
179 }
180 let debugger = DebuggerSession::start(&self.root, config, "Glass Dev", timeout)?;
181 self.debuggers.insert(name.to_string(), debugger);
182 Ok(())
183 }
184
185 pub fn debugger_mut(&mut self, name: &str) -> DebugResult<&mut DebuggerSession> {
186 self.debuggers
187 .get_mut(name)
188 .ok_or_else(|| DebugError::InvalidInput(format!("unknown debugger session {name}")))
189 }
190
191 pub fn debugger_names(&self) -> impl Iterator<Item = &str> {
192 self.debuggers.keys().map(String::as_str)
193 }
194
195 pub fn stop_debugger(&mut self, name: &str) -> DebugResult<()> {
196 let mut debugger = self
197 .debuggers
198 .remove(name)
199 .ok_or_else(|| DebugError::InvalidInput(format!("unknown debugger session {name}")))?;
200 debugger.shutdown()
201 }
202
203 pub fn git(&self) -> Option<&GitService> {
204 self.git.as_ref()
205 }
206
207 pub fn intelligence(&self) -> &DevelopmentIntelligence {
208 &self.intelligence
209 }
210
211 pub fn intelligence_mut(&mut self) -> &mut DevelopmentIntelligence {
212 &mut self.intelligence
213 }
214
215 pub fn tests(&self) -> &TestService {
216 &self.tests
217 }
218
219 pub fn tests_mut(&mut self) -> &mut TestService {
220 &mut self.tests
221 }
222
223 pub fn kernels(&self) -> &KernelManager {
224 &self.kernels
225 }
226
227 pub fn kernels_mut(&mut self) -> &mut KernelManager {
228 &mut self.kernels
229 }
230
231 pub fn language(&mut self) -> &mut LanguageService {
232 &mut self.language
233 }
234
235 pub fn knowledge(&self) -> &KnowledgeStore {
236 &self.knowledge
237 }
238
239 pub fn knowledge_mut(&mut self) -> &mut KnowledgeStore {
240 &mut self.knowledge
241 }
242
243 pub fn tool_descriptors(&self) -> Vec<glass_browser::development::ToolDescriptor> {
244 self.tools.descriptors()
245 }
246
247 pub fn execute_tool(
248 &mut self,
249 call: &glass_browser::development::ToolCall,
250 context: &DevelopmentToolContext,
251 ) -> DevelopmentResult<serde_json::Value> {
252 let router = self.tools.clone();
253 router.execute(self, call, context)
254 }
255
256 pub fn advance_generation(&mut self) -> DevelopmentResult<u64> {
258 self.generation = self.generation.checked_add(1).ok_or_else(|| {
259 glass_browser::development::DevelopmentError::Conflict(
260 "development workspace generation overflowed".into(),
261 )
262 })?;
263 Ok(self.generation)
264 }
265}
266
267fn validate_service_name(name: &str) -> DebugResult<()> {
268 if name.is_empty()
269 || name.len() > 64
270 || !name
271 .chars()
272 .all(|character| character.is_ascii_alphanumeric() || "-_".contains(character))
273 {
274 return Err(DebugError::InvalidInput(
275 "resident service names must be 1..=64 ASCII letters, digits, '-' or '_'".into(),
276 ));
277 }
278 Ok(())
279}
280
281#[derive(Clone)]
283pub struct SharedDevelopmentWorkspace {
284 inner: Arc<Mutex<DevelopmentWorkspace>>,
285}
286
287impl SharedDevelopmentWorkspace {
288 pub fn open(root: impl AsRef<Path>) -> DevelopmentResult<Self> {
289 Ok(Self {
290 inner: Arc::new(Mutex::new(DevelopmentWorkspace::open(root)?)),
291 })
292 }
293
294 pub fn lock(&self) -> DevelopmentResult<MutexGuard<'_, DevelopmentWorkspace>> {
295 self.inner.lock().map_err(|_| {
296 glass_browser::development::DevelopmentError::Conflict(
297 "development workspace lock was poisoned".into(),
298 )
299 })
300 }
301}
302
303#[cfg(test)]
304mod tests {
305 use super::*;
306 use std::sync::atomic::{AtomicU64, Ordering};
307
308 static NEXT_ROOT: AtomicU64 = AtomicU64::new(0);
309
310 fn test_root() -> PathBuf {
311 let sequence = NEXT_ROOT.fetch_add(1, Ordering::Relaxed);
312 std::env::temp_dir().join(format!(
313 "glass-dev-workspace-{}-{sequence}",
314 std::process::id()
315 ))
316 }
317
318 #[test]
319 fn shared_workspace_preserves_project_identity_across_generations() {
320 let root = test_root();
321 std::fs::create_dir_all(&root).unwrap();
322 std::fs::write(
323 root.join("Cargo.toml"),
324 "[package]\nname='fixture'\nversion='0.1.0'\n",
325 )
326 .unwrap();
327
328 let workspace = SharedDevelopmentWorkspace::open(&root).unwrap();
329 let clone = workspace.clone();
330 {
331 let mut state = workspace.lock().unwrap();
332 assert_eq!(state.generation(), 1);
333 assert_eq!(state.advance_generation().unwrap(), 2);
334 }
335 let state = clone.lock().unwrap();
336 assert_eq!(state.generation(), 2);
337 assert_eq!(state.root(), std::fs::canonicalize(&root).unwrap());
338
339 std::fs::remove_dir_all(root).unwrap();
340 }
341
342 #[test]
343 fn resident_service_names_fail_closed() {
344 assert!(validate_service_name("rust").is_ok());
345 assert!(validate_service_name("../escape").is_err());
346 assert!(validate_service_name("").is_err());
347 }
348}