Skip to main content

glass_dev/
workspace.rs

1//! Resident development workspace ownership.
2
3use 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
19/// One resident software-development workspace owned by Glass Dev.
20///
21/// The handle is deliberately distinct from the browser workspace. It remains
22/// valid while browser sessions connect, fail, or are replaced and is the
23/// ownership root for services moved into `glass-dev` during the 0.3.4 cycle.
24pub 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    /// Open a project and establish generation one of its resident state.
43    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    /// Canonical project root confining all resident development services.
135    pub fn root(&self) -> &Path {
136        &self.root
137    }
138
139    /// Current durable workspace generation.
140    pub fn generation(&self) -> u64 {
141        self.generation
142    }
143
144    /// Existing project runtime while its implementation is migrated into
145    /// this crate service by service.
146    pub fn project(&self) -> &ProjectWorkspace {
147        &self.project
148    }
149
150    /// Mutable access for governed resident service operations.
151    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    /// Start and initialize one named resident DAP session.
168    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    /// Advance the generation after replacing resident service ownership.
257    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/// Thread-safe resident handle shared by CLI, TUI, MCP and daemon clients.
282#[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}