use crate::agents::AgentRegistry;
use crate::browser::BrowserService;
use crate::customization::Customization;
use crate::debugger::{DebugAdapterConfig, DebugError, DebugResult, DebuggerSession};
use crate::git::GitService;
use crate::intelligence::{DevelopmentIntelligence, DevelopmentNode, DevelopmentNodeKind};
use crate::kernels::KernelManager;
use crate::lsp::LanguageService;
use crate::testing::{TestFramework, TestService, TestSuite};
use crate::tools::{DevelopmentToolContext, DevelopmentToolRouter};
use glass_browser::browser::session::{KnowledgeStore, default_knowledge_store_path_for_workspace};
use glass_browser::development::{DevelopmentResult, ProjectWorkspace};
use std::collections::BTreeMap;
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex, MutexGuard};
pub struct DevelopmentWorkspace {
root: PathBuf,
agents: AgentRegistry,
browser: BrowserService,
customization: Customization,
project: ProjectWorkspace,
debuggers: BTreeMap<String, DebuggerSession>,
git: Option<GitService>,
intelligence: DevelopmentIntelligence,
kernels: KernelManager,
language: LanguageService,
knowledge: KnowledgeStore,
tests: TestService,
tools: DevelopmentToolRouter,
generation: u64,
}
impl DevelopmentWorkspace {
pub fn open(root: impl AsRef<Path>) -> DevelopmentResult<Self> {
let project = ProjectWorkspace::open(root)?;
let root = project.root().to_path_buf();
let git = if root
.ancestors()
.any(|ancestor| ancestor.join(".git").exists())
{
Some(GitService::open(&root).map_err(|error| {
glass_browser::development::DevelopmentError::Process(error.to_string())
})?)
} else {
None
};
let customization = Customization::load(&root)?;
let mut tests = TestService::discover(&root).map_err(|error| {
glass_browser::development::DevelopmentError::Process(error.to_string())
})?;
for (name, configured) in &customization.config().tests {
tests
.register(TestSuite {
id: name.clone(),
name: name.clone(),
framework: TestFramework::Custom,
program: if cfg!(windows) { "cmd" } else { "sh" }.into(),
arguments: if cfg!(windows) {
vec!["/C".into(), configured.command.clone()]
} else {
vec!["-lc".into(), configured.command.clone()]
},
source: customization
.config_path()
.unwrap_or(root.as_path())
.to_path_buf(),
})
.map_err(|error| {
glass_browser::development::DevelopmentError::Process(error.to_string())
})?;
}
let kernels = KernelManager::new(&root).map_err(|error| {
glass_browser::development::DevelopmentError::Process(error.to_string())
})?;
let mut agents = AgentRegistry::new(&root)?;
agents.set_additional_system_prompt(customization.agent_instructions())?;
agents.set_defaults(
customization.config().agent.model.clone(),
customization.config().agent.reasoning.clone(),
)?;
let language = LanguageService::new(&root)?;
let browser = BrowserService::new(&root)?;
let knowledge = KnowledgeStore::open(default_knowledge_store_path_for_workspace(
"default",
&root.display().to_string(),
Some(1),
))
.map_err(|error| {
glass_browser::development::DevelopmentError::Process(error.to_string())
})?;
customization.run_hooks(
"workspace.opened",
&serde_json::json!({"root":root,"generation":1}),
)?;
let tools = DevelopmentToolRouter::with_customization(&customization);
Ok(Self {
root: root.clone(),
agents,
browser,
customization,
project,
debuggers: BTreeMap::new(),
git,
intelligence: {
let mut intelligence = DevelopmentIntelligence::default();
intelligence.upsert_node(DevelopmentNode {
id: "repository:root".into(),
kind: DevelopmentNodeKind::Repository,
label: root.display().to_string(),
revision: 0,
stale: false,
evidence: serde_json::json!({"root":root}),
})?;
intelligence
},
kernels,
language,
knowledge,
tests,
tools,
generation: 1,
})
}
pub fn root(&self) -> &Path {
&self.root
}
pub fn generation(&self) -> u64 {
self.generation
}
pub fn project(&self) -> &ProjectWorkspace {
&self.project
}
pub fn project_mut(&mut self) -> &mut ProjectWorkspace {
&mut self.project
}
pub fn agents(&mut self) -> &mut AgentRegistry {
&mut self.agents
}
pub fn browser(&self) -> &BrowserService {
&self.browser
}
pub fn customization(&self) -> &Customization {
&self.customization
}
pub fn start_debugger(
&mut self,
name: &str,
config: &DebugAdapterConfig,
timeout: std::time::Duration,
) -> DebugResult<()> {
validate_service_name(name)?;
if self.debuggers.contains_key(name) {
return Err(DebugError::InvalidInput(format!(
"debugger session {name} already exists"
)));
}
let debugger = DebuggerSession::start(&self.root, config, "Glass Dev", timeout)?;
self.debuggers.insert(name.to_string(), debugger);
Ok(())
}
pub fn debugger_mut(&mut self, name: &str) -> DebugResult<&mut DebuggerSession> {
self.debuggers
.get_mut(name)
.ok_or_else(|| DebugError::InvalidInput(format!("unknown debugger session {name}")))
}
pub fn debugger_names(&self) -> impl Iterator<Item = &str> {
self.debuggers.keys().map(String::as_str)
}
pub fn stop_debugger(&mut self, name: &str) -> DebugResult<()> {
let mut debugger = self
.debuggers
.remove(name)
.ok_or_else(|| DebugError::InvalidInput(format!("unknown debugger session {name}")))?;
debugger.shutdown()
}
pub fn git(&self) -> Option<&GitService> {
self.git.as_ref()
}
pub fn intelligence(&self) -> &DevelopmentIntelligence {
&self.intelligence
}
pub fn intelligence_mut(&mut self) -> &mut DevelopmentIntelligence {
&mut self.intelligence
}
pub fn tests(&self) -> &TestService {
&self.tests
}
pub fn tests_mut(&mut self) -> &mut TestService {
&mut self.tests
}
pub fn kernels(&self) -> &KernelManager {
&self.kernels
}
pub fn kernels_mut(&mut self) -> &mut KernelManager {
&mut self.kernels
}
pub fn language(&mut self) -> &mut LanguageService {
&mut self.language
}
pub fn knowledge(&self) -> &KnowledgeStore {
&self.knowledge
}
pub fn knowledge_mut(&mut self) -> &mut KnowledgeStore {
&mut self.knowledge
}
pub fn tool_descriptors(&self) -> Vec<glass_browser::development::ToolDescriptor> {
self.tools.descriptors()
}
pub fn execute_tool(
&mut self,
call: &glass_browser::development::ToolCall,
context: &DevelopmentToolContext,
) -> DevelopmentResult<serde_json::Value> {
let router = self.tools.clone();
router.execute(self, call, context)
}
pub fn advance_generation(&mut self) -> DevelopmentResult<u64> {
self.generation = self.generation.checked_add(1).ok_or_else(|| {
glass_browser::development::DevelopmentError::Conflict(
"development workspace generation overflowed".into(),
)
})?;
Ok(self.generation)
}
}
fn validate_service_name(name: &str) -> DebugResult<()> {
if name.is_empty()
|| name.len() > 64
|| !name
.chars()
.all(|character| character.is_ascii_alphanumeric() || "-_".contains(character))
{
return Err(DebugError::InvalidInput(
"resident service names must be 1..=64 ASCII letters, digits, '-' or '_'".into(),
));
}
Ok(())
}
#[derive(Clone)]
pub struct SharedDevelopmentWorkspace {
inner: Arc<Mutex<DevelopmentWorkspace>>,
}
impl SharedDevelopmentWorkspace {
pub fn open(root: impl AsRef<Path>) -> DevelopmentResult<Self> {
Ok(Self {
inner: Arc::new(Mutex::new(DevelopmentWorkspace::open(root)?)),
})
}
pub fn lock(&self) -> DevelopmentResult<MutexGuard<'_, DevelopmentWorkspace>> {
self.inner.lock().map_err(|_| {
glass_browser::development::DevelopmentError::Conflict(
"development workspace lock was poisoned".into(),
)
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::atomic::{AtomicU64, Ordering};
static NEXT_ROOT: AtomicU64 = AtomicU64::new(0);
fn test_root() -> PathBuf {
let sequence = NEXT_ROOT.fetch_add(1, Ordering::Relaxed);
std::env::temp_dir().join(format!(
"glass-dev-workspace-{}-{sequence}",
std::process::id()
))
}
#[test]
fn shared_workspace_preserves_project_identity_across_generations() {
let root = test_root();
std::fs::create_dir_all(&root).unwrap();
std::fs::write(
root.join("Cargo.toml"),
"[package]\nname='fixture'\nversion='0.1.0'\n",
)
.unwrap();
let workspace = SharedDevelopmentWorkspace::open(&root).unwrap();
let clone = workspace.clone();
{
let mut state = workspace.lock().unwrap();
assert_eq!(state.generation(), 1);
assert_eq!(state.advance_generation().unwrap(), 2);
}
let state = clone.lock().unwrap();
assert_eq!(state.generation(), 2);
assert_eq!(state.root(), std::fs::canonicalize(&root).unwrap());
std::fs::remove_dir_all(root).unwrap();
}
#[test]
fn resident_service_names_fail_closed() {
assert!(validate_service_name("rust").is_ok());
assert!(validate_service_name("../escape").is_err());
assert!(validate_service_name("").is_err());
}
}