1use crate::agents::AgentSpec;
4use crate::browser::BrowserStartConfig;
5use crate::debugger::{DebugAdapterConfig, SourceBreakpoint};
6use crate::kernels::KernelKind;
7use crate::workspace::DevelopmentWorkspace;
8use crate::{DevelopmentNode, DevelopmentNodeKind, ObservableEventInput};
9use glass_browser::browser::session::{
10 SemanticObservationLevel, WorkflowRecordingSession, record_semantic_events,
11};
12use glass_browser::development::{
13 AgentToolGateway, DevelopmentError, DevelopmentResult, HarnessRequest, ToolAuthorization,
14 ToolCall, ToolDescriptor,
15};
16use serde_json::Value;
17use std::path::PathBuf;
18use std::time::Duration;
19
20const RESULT_LIMIT: usize = 512 * 1024;
21
22#[derive(Debug, Clone)]
23pub struct DevelopmentToolContext {
24 pub authorization: ToolAuthorization,
25 pub expected_generation: u64,
26 pub expected_project_revision: u64,
27}
28
29#[derive(Debug, Clone)]
31pub struct DevelopmentToolRouter {
32 core: AgentToolGateway,
33 descriptors: Vec<ToolDescriptor>,
34}
35
36impl Default for DevelopmentToolRouter {
37 fn default() -> Self {
38 let core = AgentToolGateway::default();
39 let service = service_descriptors();
40 let mut descriptors = core
41 .descriptors()
42 .into_iter()
43 .filter(|descriptor| {
44 !service
45 .iter()
46 .any(|candidate| candidate.name == descriptor.name)
47 })
48 .collect::<Vec<_>>();
49 descriptors.extend(service);
50 Self { core, descriptors }
51 }
52}
53
54impl DevelopmentToolRouter {
55 pub fn with_customization(customization: &crate::Customization) -> Self {
56 let mut router = Self::default();
57 let custom = customization.descriptors();
58 router
59 .descriptors
60 .retain(|descriptor| !custom.iter().any(|item| item.name == descriptor.name));
61 router.descriptors.extend(custom);
62 router
63 }
64
65 pub fn descriptors(&self) -> Vec<ToolDescriptor> {
66 self.descriptors.clone()
67 }
68
69 pub fn execute(
70 &self,
71 workspace: &mut DevelopmentWorkspace,
72 call: &ToolCall,
73 context: &DevelopmentToolContext,
74 ) -> DevelopmentResult<Value> {
75 if workspace.generation() != context.expected_generation {
76 return Err(DevelopmentError::Conflict(format!(
77 "stale workspace generation {}; current generation is {}",
78 context.expected_generation,
79 workspace.generation()
80 )));
81 }
82 if workspace.project().revision() != context.expected_project_revision {
83 return Err(DevelopmentError::Conflict(format!(
84 "stale project revision {}; current revision is {}",
85 context.expected_project_revision,
86 workspace.project().revision()
87 )));
88 }
89 let descriptor = self
90 .descriptors
91 .iter()
92 .find(|descriptor| descriptor.name == call.name)
93 .ok_or_else(|| DevelopmentError::NotFound(format!("tool {}", call.name)))?;
94 if descriptor.mutating
95 && (!context.authorization.allow_mutation || !context.authorization.confirmed)
96 {
97 return Err(DevelopmentError::Conflict(format!(
98 "tool {} requires mutation authority and confirmation",
99 call.name
100 )));
101 }
102 let actor_id = context.authorization.actor.id.clone();
103 let project_revision = workspace.project().revision();
104 let resource = format!("tool:{}", call.id);
105 let argument_bytes = serde_json::to_vec(&call.arguments)?.len();
106 workspace.intelligence_mut().upsert_node(DevelopmentNode {
107 id: resource.clone(),
108 kind: DevelopmentNodeKind::ToolCall,
109 label: call.name.clone(),
110 revision: project_revision,
111 stale: false,
112 evidence: serde_json::json!({
113 "toolCallId":call.id,
114 "name":call.name,
115 "mutating":descriptor.mutating,
116 "argumentBytes":argument_bytes
117 }),
118 })?;
119 workspace.intelligence_mut().link(
120 "repository:root",
121 &resource,
122 "receivedToolCall",
123 project_revision,
124 &actor_id,
125 serde_json::json!({"name":call.name}),
126 )?;
127 workspace.intelligence_mut().record(ObservableEventInput {
128 actor: &actor_id,
129 subsystem: "tool",
130 kind: "called",
131 resource: Some(&resource),
132 workspace_revision: project_revision,
133 evidence: serde_json::json!({"name":call.name,"mutating":descriptor.mutating}),
134 rationale: None,
135 })?;
136 workspace.customization().run_hooks(
137 "tool.before",
138 &serde_json::json!({"id":call.id,"name":call.name,"actor":&actor_id}),
139 )?;
140 let result = if service_descriptors()
141 .iter()
142 .any(|descriptor| descriptor.name == call.name)
143 {
144 self.execute_service(workspace, call, context)
145 } else if workspace.customization().custom_tool(&call.name).is_some() {
146 workspace
147 .customization()
148 .execute_tool(&call.name, &call.arguments)
149 } else if let Some(name) = call.name.strip_prefix("glass.command.") {
150 workspace.customization().execute_command(name)
151 } else {
152 self.core
153 .execute(workspace.project_mut(), call, &context.authorization)
154 };
155 match result {
156 Ok(result) => {
157 workspace.customization().run_hooks(
158 "tool.after",
159 &serde_json::json!({"id":call.id,"name":call.name,"actor":&actor_id,"ok":true}),
160 )?;
161 let result_bytes = serde_json::to_vec(&result)?.len();
162 if result_bytes > RESULT_LIMIT {
163 return Err(DevelopmentError::InvalidInput(format!(
164 "tool result exceeds the {RESULT_LIMIT} byte limit"
165 )));
166 }
167 let resulting_revision = workspace.project().revision();
168 workspace.intelligence_mut().record(ObservableEventInput {
169 actor: &actor_id,
170 subsystem: "tool",
171 kind: "completed",
172 resource: Some(&resource),
173 workspace_revision: resulting_revision,
174 evidence: serde_json::json!({"name":call.name,"resultBytes":result_bytes}),
175 rationale: None,
176 })?;
177 Ok(result)
178 }
179 Err(error) => {
180 workspace.customization().run_hooks(
181 "tool.after",
182 &serde_json::json!({"id":call.id,"name":call.name,"actor":&actor_id,"ok":false,"error":error.to_string()}),
183 )?;
184 let resulting_revision = workspace.project().revision();
185 workspace.intelligence_mut().record(ObservableEventInput {
186 actor: &actor_id,
187 subsystem: "tool",
188 kind: "failed",
189 resource: Some(&resource),
190 workspace_revision: resulting_revision,
191 evidence: serde_json::json!({"name":call.name,"error":error.to_string()}),
192 rationale: None,
193 })?;
194 Err(error)
195 }
196 }
197 }
198
199 fn execute_service(
200 &self,
201 workspace: &mut DevelopmentWorkspace,
202 call: &ToolCall,
203 context: &DevelopmentToolContext,
204 ) -> DevelopmentResult<Value> {
205 let string = |name: &str| required_string(call, name);
206 let actor = normalized_actor_id(&context.authorization.actor.id);
207 match call.name.as_str() {
208 "glass.editor.open" => map_service(
209 workspace
210 .project_mut()
211 .open_buffer(string("path")?, context.authorization.actor.clone()),
212 ),
213 "glass.editor.selection" => {
214 let path = string("path")?;
215 workspace
216 .project()
217 .buffer(path)
218 .cloned()
219 .map(|buffer| {
220 serde_json::json!({
221 "path":buffer.path,
222 "line":buffer.cursor_line,
223 "column":buffer.cursor_column,
224 "actor":buffer.actor,
225 "dirty":buffer.dirty
226 })
227 })
228 .ok_or_else(|| DevelopmentError::NotFound(format!("buffer {path}")))
229 }
230 "glass.editor.replace" => {
231 let matches = workspace.project_mut().replace_in_buffer(
232 string("path")?,
233 string("oldText")?,
234 string("newText")?,
235 context.authorization.actor.clone(),
236 )?;
237 Ok(serde_json::json!({"replacements":matches}))
238 }
239 "glass.editor.save" => {
240 map_service(workspace.project_mut().save_buffer(string("path")?))
241 }
242 "glass.editor.diff" => map_service(workspace.project_mut().diff()),
243 "glass.editor.buffers" => Ok(serde_json::to_value(
244 workspace.project().buffers().cloned().collect::<Vec<_>>(),
245 )?),
246 "glass.process.restart" => {
247 map_service(workspace.project_mut().processes().restart(string("name")?))
248 }
249 "glass.process.input" => {
250 workspace
251 .project_mut()
252 .processes()
253 .send_input(string("name")?, string("input")?)?;
254 Ok(serde_json::json!({"sent":true}))
255 }
256 "glass.process.resize" => {
257 let cols = u16_value(call, "cols")?;
258 let rows = u16_value(call, "rows")?;
259 workspace
260 .project_mut()
261 .processes()
262 .resize(string("name")?, cols, rows)?;
263 Ok(serde_json::json!({"resized":true,"cols":cols,"rows":rows}))
264 }
265 "glass.process.health" => {
266 let name = string("name")?;
267 let snapshot = workspace
268 .project_mut()
269 .processes()
270 .list_checked()?
271 .into_iter()
272 .find(|snapshot| snapshot.name == name)
273 .ok_or_else(|| DevelopmentError::NotFound(format!("process {name}")))?;
274 Ok(serde_json::json!({
275 "name":snapshot.name,
276 "pid":snapshot.pid,
277 "state":snapshot.state,
278 "health":snapshot.health,
279 "detectedUrls":snapshot.detected_urls
280 }))
281 }
282 "glass.process.ports" => {
283 let snapshots = workspace.project_mut().processes().list_checked()?;
284 Ok(serde_json::json!({
285 "processes":snapshots.into_iter().map(|snapshot| serde_json::json!({
286 "name":snapshot.name,
287 "pid":snapshot.pid,
288 "urls":snapshot.detected_urls
289 })).collect::<Vec<_>>()
290 }))
291 }
292 "glass.browser.start" => {
293 let config: BrowserStartConfig = serde_json::from_value(call.arguments.clone())?;
294 workspace.browser().start(config)
295 }
296 "glass.browser.stop" => workspace.browser().stop(),
297 "glass.browser.attach" => {
298 let mut config: BrowserStartConfig = serde_json::from_value(call.arguments.clone())?;
299 config.attach = true;
300 workspace.browser().start(config)
301 }
302 "glass.browser.reconnect" => workspace.browser().reconnect(),
303 "glass.browser.state" => workspace.browser().state(),
304 "glass.browser.observe" => workspace.browser().observe(),
305 "glass.browser.snapshot" => workspace.browser().snapshot(),
306 "glass.browser.semantic" => workspace.browser().semantic(match optional_string(call, "level").unwrap_or("structured") {
307 "summary" => SemanticObservationLevel::Summary,
308 "interactive" => SemanticObservationLevel::Interactive,
309 "structured" => SemanticObservationLevel::Structured,
310 "detailed" => SemanticObservationLevel::Detailed,
311 "raw" => SemanticObservationLevel::Raw,
312 _ => return Err(DevelopmentError::InvalidInput("browser semantic level must be summary, interactive, structured, detailed, or raw".into())),
313 }),
314 "glass.browser.diff" => workspace.browser().diff(),
315 "glass.browser.targets" => workspace.browser().targets(),
316 "glass.browser.target.select" => workspace
317 .browser()
318 .select_target(string("targetId")?.into()),
319 "glass.browser.navigate" => workspace.browser().navigate(
320 string("url")?.into(),
321 unsigned(call, "browserRevision", 0)?,
322 timeout(call, 180)?.unwrap_or(Duration::from_secs(30)),
323 ),
324 "glass.browser.act" => {
325 let revision = unsigned(call, "browserRevision", 0)?;
326 match string("action")? {
327 "click" => workspace
328 .browser()
329 .click(string("target")?.into(), revision),
330 "type" => workspace.browser().type_text(
331 string("text")?.into(),
332 optional_string(call, "target").map(str::to_string),
333 revision,
334 ),
335 "scroll" => workspace.browser().scroll(
336 number(call, "dx", 0.0)?,
337 number(call, "dy", 0.0)?,
338 revision,
339 ),
340 action => Err(DevelopmentError::InvalidInput(format!(
341 "unsupported browser action {action}; expected click, type, or scroll"
342 ))),
343 }
344 }
345 "glass.browser.screenshot" => workspace.browser().screenshot(),
346 "glass.workflow.list" => workspace.browser().list_workflows(),
347 "glass.workflow.run" => workspace.browser().run_workflow(
348 required_value(call, "definition")?.clone(),
349 value_map(call, "inputs")?,
350 ),
351 "glass.workflow.pause" => workspace.browser().pause_workflow(),
352 "glass.workflow.resume" => workspace.browser().resume_workflow(
353 required_value(call, "definition")?.clone(),
354 value_map(call, "inputs")?,
355 required_value(call, "checkpoint")?.clone(),
356 ),
357 "glass.workflow.cancel" => workspace.browser().cancel_workflow(),
358 "glass.workflow.verify" => workspace.browser().verify_workflow(),
359 "glass.workflow.record" => {
360 let session: WorkflowRecordingSession = serde_json::from_value(
361 required_value(call, "session")?.clone(),
362 )?;
363 Ok(serde_json::to_value(record_semantic_events(session).map_err(|error| {
364 DevelopmentError::InvalidInput(error.to_string())
365 })?)?)
366 }
367 "glass.memory.retrieve" => {
368 if let Some(record_id) = optional_string(call, "recordId") {
369 Ok(serde_json::to_value(
370 workspace
371 .knowledge()
372 .get(record_id)
373 .ok_or_else(|| DevelopmentError::NotFound(format!("memory record {record_id}")))?,
374 )?)
375 } else {
376 Ok(serde_json::json!({
377 "records":workspace.knowledge().records(),
378 "stats":workspace.knowledge().stats().map_err(|error| DevelopmentError::Process(error.to_string()))?
379 }))
380 }
381 }
382 "glass.memory.explain" => {
383 let record_id = string("recordId")?;
384 let record = workspace
385 .knowledge()
386 .get(record_id)
387 .ok_or_else(|| DevelopmentError::NotFound(format!("memory record {record_id}")))?;
388 Ok(serde_json::json!({
389 "record":record,
390 "advisory":true,
391 "authority":"fresh browser evidence remains authoritative"
392 }))
393 }
394 "glass.memory.forget" => {
395 let record_id = string("recordId")?;
396 let change = workspace
397 .knowledge_mut()
398 .remove(record_id)
399 .map_err(|error| DevelopmentError::Process(error.to_string()))?;
400 Ok(serde_json::to_value(change)?)
401 }
402 "glass.semantic.inspect" => workspace
403 .browser()
404 .semantic(SemanticObservationLevel::Structured),
405 "glass.semantic.diff" => workspace.browser().diff(),
406 "glass.semantic.links" => Ok(serde_json::json!({
407 "nodes":workspace.intelligence().nodes().collect::<Vec<_>>(),
408 "edges":workspace.intelligence().edges().collect::<Vec<_>>()
409 })),
410 "glass.git.status" => git_value(workspace.git(), |git| git.status()),
411 "glass.git.diff" => git_value(workspace.git(), |git| {
412 git.diff(
413 boolean(call, "staged", false),
414 optional_string(call, "path"),
415 )
416 }),
417 "glass.git.stage" => {
418 let paths = string_array(call, "paths")?;
419 git_mutation(workspace.git(), |git| git.stage(&paths))?;
420 Ok(serde_json::json!({"staged":paths}))
421 }
422 "glass.git.unstage" => {
423 let paths = string_array(call, "paths")?;
424 git_mutation(workspace.git(), |git| git.unstage(&paths))?;
425 Ok(serde_json::json!({"unstaged":paths}))
426 }
427 "glass.git.commit" => {
428 let message = string("message")?;
429 git_value(workspace.git(), |git| git.commit(message))
430 }
431 "glass.git.branches" => git_value(workspace.git(), |git| git.branches()),
432 "glass.git.branch.create" => {
433 let name = string("name")?;
434 let start_point = optional_string(call, "startPoint");
435 git_mutation(workspace.git(), |git| git.create_branch(name, start_point))?;
436 Ok(serde_json::json!({"created":name}))
437 }
438 "glass.git.branch.switch" => {
439 let name = string("name")?;
440 let create = boolean(call, "create", false);
441 git_mutation(workspace.git(), |git| git.switch_branch(name, create))?;
442 Ok(serde_json::json!({"current":name}))
443 }
444 "glass.git.blame" => {
445 let path = string("path")?;
446 let start = unsigned(call, "startLine", 1)?;
447 let end = unsigned(call, "endLine", 1)?;
448 git_value(workspace.git(), |git| git.blame(path, start, end))
449 }
450 "glass.git.conflicts" => git_value(workspace.git(), |git| git.conflicts()),
451 "glass.git.stash.list" => git_value(workspace.git(), |git| git.stash_list()),
452 "glass.git.stash.push" => {
453 let message = string("message")?;
454 let include_untracked = boolean(call, "includeUntracked", false);
455 git_mutation(workspace.git(), |git| {
456 git.stash_push(message, include_untracked)
457 })?;
458 Ok(serde_json::json!({"stashed":true}))
459 }
460 "glass.git.stash.pop" => {
461 let reference = string("reference")?;
462 git_mutation(workspace.git(), |git| git.stash_pop(reference))?;
463 Ok(serde_json::json!({"restored":reference}))
464 }
465 "glass.git.worktree.list" => git_value(workspace.git(), |git| git.worktrees()),
466 "glass.git.worktree.create" => {
467 let path = PathBuf::from(string("path")?);
468 let branch = string("branch")?;
469 let create_branch = boolean(call, "createBranch", true);
470 git_mutation(workspace.git(), |git| {
471 git.create_worktree(&path, branch, create_branch)
472 })?;
473 Ok(serde_json::json!({"path":path,"created":true}))
474 }
475 "glass.git.worktree.remove" => {
476 let path = PathBuf::from(string("path")?);
477 git_mutation(workspace.git(), |git| {
478 git.remove_worktree(&path, boolean(call, "force", false))
479 })?;
480 Ok(serde_json::json!({"path":path,"removed":true}))
481 }
482 "glass.test.discover" => Ok(serde_json::to_value(
483 workspace.tests().suites().collect::<Vec<_>>(),
484 )?),
485 "glass.test.run" => {
486 let revision = workspace.project().revision();
487 map_service(workspace.tests_mut().start(
488 string("runId")?,
489 string("suiteId")?,
490 &actor,
491 revision,
492 timeout(call, 3_600)?,
493 ))
494 }
495 "glass.test.run-affected" => {
496 let paths = string_array(call, "changedPaths")?;
497 let suite_ids = workspace
498 .tests()
499 .affected_suites(paths.iter().map(String::as_str))
500 .into_iter()
501 .map(|suite| suite.id.clone())
502 .collect::<Vec<_>>();
503 let revision = workspace.project().revision();
504 let prefix = optional_string(call, "runPrefix").unwrap_or("affected");
505 let mut runs = Vec::new();
506 for (index, suite_id) in suite_ids.into_iter().enumerate() {
507 runs.push(map_service(workspace.tests_mut().start(
508 &format!("{prefix}-{index}"),
509 &suite_id,
510 &actor,
511 revision,
512 timeout(call, 3_600)?,
513 ))?);
514 }
515 Ok(serde_json::to_value(runs)?)
516 }
517 "glass.test.cancel" => {
518 map_service(workspace.tests_mut().cancel(string("runId")?))?;
519 Ok(serde_json::json!({"cancelled":string("runId")?}))
520 }
521 "glass.test.results" => {
522 let finished = map_service(workspace.tests_mut().poll())?;
523 Ok(serde_json::json!({
524 "finished":finished,
525 "running":workspace.tests().running().collect::<Vec<_>>(),
526 "results":workspace.tests().results().collect::<Vec<_>>()
527 }))
528 }
529 "glass.test.watch" => {
530 let revision = workspace.project().revision();
531 map_service(workspace.tests_mut().watch(string("suiteId")?, revision))?;
532 Ok(serde_json::json!({"watching":string("suiteId")?}))
533 }
534 "glass.eval.start" => {
535 let kind = parse_kernel_kind(string("kind")?)?;
536 map_service(workspace.kernels_mut().start(string("name")?, kind, &actor))?;
537 Ok(serde_json::json!({"started":string("name")?,"kind":kind}))
538 }
539 "glass.eval.execute" => {
540 let revision = workspace.project().revision();
541 map_service(workspace.kernels_mut().execute(
542 string("name")?,
543 string("code")?,
544 &actor,
545 revision,
546 timeout(call, 600)?,
547 ))
548 }
549 "glass.eval.list" => Ok(serde_json::to_value(
550 workspace.kernels().snapshots().collect::<Vec<_>>(),
551 )?),
552 "glass.eval.reset" => {
553 map_service(workspace.kernels_mut().reset(string("name")?, &actor))?;
554 Ok(serde_json::json!({"reset":string("name")?}))
555 }
556 "glass.eval.stop" => map_service(workspace.kernels_mut().stop(string("name")?)),
557 "glass.lsp.start" => {
558 let server = string("server")?;
559 let configured = workspace.customization().config().lsp.get(server).cloned();
560 let config = match (optional_string(call, "command"), configured) {
561 (Some(command), _) => crate::lsp::LanguageServerConfig {
562 command: command.to_string(),
563 arguments: string_array_or_empty(call, "arguments")?,
564 },
565 (None, Some(config)) => crate::lsp::LanguageServerConfig {
566 command: config.command,
567 arguments: config.args,
568 },
569 (None, None) => return Err(DevelopmentError::InvalidInput(
570 "lsp start requires command or a matching glass.toml lsp entry".into(),
571 )),
572 };
573 map_service(workspace.language().start(server, &config))?;
574 Ok(serde_json::json!({"started":server}))
575 }
576 "glass.lsp.stop" => {
577 map_service(workspace.language().stop(string("server")?))?;
578 Ok(serde_json::json!({"stopped":string("server")?}))
579 }
580 "glass.lsp.list" => Ok(serde_json::json!({
581 "servers":workspace.language().names().collect::<Vec<_>>()
582 })),
583 "glass.lsp.events" => Ok(serde_json::to_value(
584 workspace.language().events(unsigned(call, "since", 0)?),
585 )?),
586 "glass.lsp.raw" => map_service(workspace.language().raw_request(
587 string("server")?,
588 &actor,
589 string("method")?,
590 call.arguments
591 .get("params")
592 .cloned()
593 .unwrap_or_else(|| serde_json::json!({})),
594 timeout(call, 60)?.unwrap_or(Duration::from_secs(10)),
595 )),
596 "glass.lsp.diagnostics" => map_service(workspace.language().diagnostics(
597 string("server")?,
598 &actor,
599 string("path")?,
600 )),
601 "glass.lsp.hover" => map_service(workspace.language().hover(
602 string("server")?,
603 &actor,
604 string("path")?,
605 unsigned(call, "line", 1)? as u32,
606 unsigned(call, "character", 1)? as u32,
607 )),
608 "glass.lsp.completion" => map_service(workspace.language().completion(
609 string("server")?,
610 &actor,
611 string("path")?,
612 unsigned(call, "line", 1)? as u32,
613 unsigned(call, "character", 1)? as u32,
614 )),
615 "glass.lsp.definition" => map_service(workspace.language().definition(
616 string("server")?,
617 &actor,
618 string("path")?,
619 u32_value(call, "line")?,
620 u32_value(call, "character")?,
621 )),
622 "glass.lsp.declaration" => map_service(workspace.language().declaration(
623 string("server")?,
624 &actor,
625 string("path")?,
626 u32_value(call, "line")?,
627 u32_value(call, "character")?,
628 )),
629 "glass.lsp.implementation" => map_service(workspace.language().implementation(
630 string("server")?,
631 &actor,
632 string("path")?,
633 u32_value(call, "line")?,
634 u32_value(call, "character")?,
635 )),
636 "glass.lsp.references" => map_service(workspace.language().references(
637 string("server")?,
638 &actor,
639 string("path")?,
640 u32_value(call, "line")?,
641 u32_value(call, "character")?,
642 )),
643 "glass.lsp.document_symbols" => map_service(workspace.language().document_symbols(
644 string("server")?,
645 &actor,
646 string("path")?,
647 )),
648 "glass.lsp.workspace_symbols" => map_service(workspace.language().workspace_symbols(
649 string("server")?,
650 &actor,
651 string("query")?,
652 )),
653 "glass.lsp.signature_help" => map_service(workspace.language().signature_help(
654 string("server")?,
655 &actor,
656 string("path")?,
657 u32_value(call, "line")?,
658 u32_value(call, "character")?,
659 )),
660 "glass.lsp.code_actions" => map_service(workspace.language().code_actions(
661 string("server")?,
662 &actor,
663 string("path")?,
664 position(call, "start")?,
665 position(call, "end")?,
666 value_array_or_empty(call, "diagnostics")?,
667 )),
668 "glass.lsp.formatting" => map_service(workspace.language().formatting(
669 string("server")?,
670 &actor,
671 string("path")?,
672 )),
673 "glass.lsp.range_formatting" => map_service(workspace.language().range_formatting(
674 string("server")?,
675 &actor,
676 string("path")?,
677 position(call, "start")?,
678 position(call, "end")?,
679 )),
680 "glass.lsp.semantic_tokens" => map_service(workspace.language().semantic_tokens(
681 string("server")?,
682 &actor,
683 string("path")?,
684 )),
685 "glass.lsp.rename" => map_service(workspace.language().rename(
686 string("server")?,
687 &actor,
688 string("path")?,
689 u32_value(call, "line")?,
690 u32_value(call, "character")?,
691 string("newName")?,
692 )),
693 "glass.debug.start" => {
694 let session = string("session")?;
695 let configured = workspace.customization().config().dap.get(session).cloned();
696 let config = match (optional_string(call, "command"), configured) {
697 (Some(command), _) => DebugAdapterConfig::new(
698 command,
699 string_array_or_empty(call, "arguments")?,
700 ),
701 (None, Some(config)) => DebugAdapterConfig::new(config.command, config.args),
702 (None, None) => return Err(DevelopmentError::InvalidInput(
703 "debug start requires command or a matching glass.toml dap entry".into(),
704 )),
705 };
706 map_debug(workspace.start_debugger(
707 session,
708 &config,
709 Duration::from_secs(unsigned(call, "timeoutSeconds", 30)?),
710 ))?;
711 Ok(serde_json::json!({"started":session}))
712 }
713 "glass.debug.launch" => map_debug(
714 debugger(workspace, string("session")?)?.launch(
715 call.arguments
716 .get("configuration")
717 .cloned()
718 .unwrap_or(Value::Null),
719 ),
720 ),
721 "glass.debug.attach" => map_debug(
722 debugger(workspace, string("session")?)?.attach(
723 call.arguments
724 .get("configuration")
725 .cloned()
726 .unwrap_or(Value::Null),
727 ),
728 ),
729 "glass.debug.configuration_done" => {
730 map_debug(debugger(workspace, string("session")?)?.configuration_done())
731 }
732 "glass.debug.restart" => map_debug(
733 debugger(workspace, string("session")?)?.restart(
734 call.arguments
735 .get("configuration")
736 .cloned()
737 .unwrap_or_else(|| serde_json::json!({})),
738 ),
739 ),
740 "glass.debug.breakpoint.set" => {
741 let lines = unsigned_array(call, "lines")?;
742 let breakpoints = lines
743 .iter()
744 .copied()
745 .map(SourceBreakpoint::line)
746 .collect::<Vec<_>>();
747 map_debug(
748 debugger(workspace, string("session")?)?
749 .set_source_breakpoints(&PathBuf::from(string("path")?), &breakpoints),
750 )
751 }
752 "glass.debug.breakpoint.remove" => map_debug(
753 debugger(workspace, string("session")?)?
754 .set_source_breakpoints(&PathBuf::from(string("path")?), &[]),
755 ),
756 "glass.debug.exception.set" => map_debug(
757 debugger(workspace, string("session")?)?
758 .set_exception_breakpoints(&string_array_or_empty(call, "filters")?),
759 ),
760 "glass.debug.continue" => map_debug(
761 debugger(workspace, string("session")?)?
762 .continue_thread(integer(call, "threadId")?),
763 ),
764 "glass.debug.pause" => map_debug(
765 debugger(workspace, string("session")?)?.pause(integer(call, "threadId")?),
766 ),
767 "glass.debug.step" => {
768 let debugger = debugger(workspace, string("session")?)?;
769 let thread = integer(call, "threadId")?;
770 match string("kind")? {
771 "over" => map_debug(debugger.next(thread)),
772 "in" => map_debug(debugger.step_in(thread)),
773 "out" => map_debug(debugger.step_out(thread)),
774 _ => Err(DevelopmentError::InvalidInput(
775 "debug step kind must be over, in, or out".into(),
776 )),
777 }
778 }
779 "glass.debug.threads" => map_debug(debugger(workspace, string("session")?)?.threads()),
780 "glass.debug.stack" => map_debug(
781 debugger(workspace, string("session")?)?.stack_trace(integer(call, "threadId")?),
782 ),
783 "glass.debug.scopes" => map_debug(
784 debugger(workspace, string("session")?)?.scopes(integer(call, "frameId")?),
785 ),
786 "glass.debug.variables" => map_debug(
787 debugger(workspace, string("session")?)?
788 .variables(integer(call, "variablesReference")?),
789 ),
790 "glass.debug.evaluate" => map_debug(debugger(workspace, string("session")?)?.evaluate(
791 string("expression")?,
792 call.arguments.get("frameId").and_then(Value::as_i64),
793 optional_string(call, "context").unwrap_or("repl"),
794 )),
795 "glass.debug.events" => {
796 map_debug(debugger(workspace, string("session")?)?.poll_events())
797 }
798 "glass.debug.disconnect" => map_debug(
799 debugger(workspace, string("session")?)?
800 .disconnect(boolean(call, "terminateDebuggee", false)),
801 ),
802 "glass.debug.terminate" => map_debug(
803 debugger(workspace, string("session")?)?
804 .terminate(boolean(call, "restart", false)),
805 ),
806 "glass.debug.stop" => {
807 map_debug(workspace.stop_debugger(string("session")?))?;
808 Ok(serde_json::json!({"stopped":string("session")?}))
809 }
810 "glass.agent.list" => map_service(workspace.agents().list()),
811 "glass.agent.spawn" => {
812 let spec: AgentSpec =
813 serde_json::from_value(call.arguments.get("spec").cloned().ok_or_else(
814 || DevelopmentError::InvalidInput("agent spawn requires spec".into()),
815 )?)?;
816 map_service(workspace.agents().create(spec))
817 }
818 "glass.agent.prompt" => {
819 let id = agent_id(workspace, string("agentId")?)?;
820 map_service(workspace.agents().prompt(&id, string("text")?))?;
821 Ok(serde_json::json!({"queued":true}))
822 }
823 "glass.agent.steer" => {
824 let id = agent_id(workspace, string("agentId")?)?;
825 map_service(workspace.agents().steer(&id, string("text")?))?;
826 Ok(serde_json::json!({"queued":true}))
827 }
828 "glass.agent.follow-up" => {
829 let id = agent_id(workspace, string("agentId")?)?;
830 map_service(workspace.agents().follow_up(&id, string("text")?))?;
831 Ok(serde_json::json!({"queued":true}))
832 }
833 "glass.agent.abort" => {
834 let id = agent_id(workspace, string("agentId")?)?;
835 map_service(workspace.agents().cancel(&id))?;
836 Ok(serde_json::json!({"cancelled":true}))
837 }
838 "glass.agent.compact" => {
839 let id = agent_id(workspace, string("agentId")?)?;
840 map_service(workspace.agents().request(
841 &id,
842 HarnessRequest::Compact {
843 instructions: optional_string(call, "instructions").map(str::to_string),
844 },
845 ))?;
846 Ok(serde_json::json!({"queued":true}))
847 }
848 "glass.agent.model" => {
849 let id = agent_id(workspace, string("agentId")?)?;
850 map_service(workspace.agents().request(
851 &id,
852 HarnessRequest::SetModel {
853 provider: string("provider")?.into(),
854 model_id: string("modelId")?.into(),
855 },
856 ))?;
857 Ok(serde_json::json!({"queued":true}))
858 }
859 "glass.agent.thinking" => {
860 let id = agent_id(workspace, string("agentId")?)?;
861 map_service(workspace.agents().request(
862 &id,
863 HarnessRequest::SetThinking {
864 level: string("level")?.into(),
865 },
866 ))?;
867 Ok(serde_json::json!({"queued":true}))
868 }
869 "glass.agent.new-session" => agent_request(workspace, call, HarnessRequest::NewSession),
870 "glass.agent.clone-session" => {
871 agent_request(workspace, call, HarnessRequest::CloneSession)
872 }
873 "glass.agent.fork" => agent_request(
874 workspace,
875 call,
876 HarnessRequest::Fork {
877 entry_id: string("entryId")?.into(),
878 },
879 ),
880 "glass.agent.switch-session" => agent_request(
881 workspace,
882 call,
883 HarnessRequest::SwitchSession {
884 path: string("path")?.into(),
885 },
886 ),
887 "glass.agent.messages" => agent_request(workspace, call, HarnessRequest::Messages),
888 "glass.agent.entries" => agent_request(
889 workspace,
890 call,
891 HarnessRequest::Entries {
892 since: optional_string(call, "since").map(str::to_string),
893 },
894 ),
895 "glass.agent.stats" => agent_request(workspace, call, HarnessRequest::SessionStats),
896 "glass.agent.name" => agent_request(
897 workspace,
898 call,
899 HarnessRequest::SetSessionName {
900 name: string("name")?.into(),
901 },
902 ),
903 "glass.graph.query" => Ok(serde_json::to_value(
904 workspace.intelligence().node(string("id")?),
905 )?),
906 "glass.graph.path" | "glass.graph.explain" => Ok(serde_json::to_value(
907 workspace
908 .intelligence()
909 .path(string("from")?, string("to")?)?,
910 )?),
911 "glass.replay.list" | "glass.replay.inspect" => {
912 Ok(serde_json::to_value(workspace.intelligence().replay(
913 unsigned(call, "since", 0)?,
914 usize::try_from(unsigned(call, "limit", 128)?).unwrap_or(4096),
915 )?)?)
916 }
917 "glass.replay.diff" => Ok(serde_json::to_value(
918 workspace
919 .intelligence()
920 .replay_diff(unsigned(call, "from", 0)?, unsigned(call, "to", 1)?)?,
921 )?),
922 _ => Err(DevelopmentError::NotFound(format!("tool {}", call.name))),
923 }
924 }
925}
926
927fn service_descriptors() -> Vec<ToolDescriptor> {
928 const READ: &[&str] = &[
929 "glass.git.status",
930 "glass.git.diff",
931 "glass.git.branches",
932 "glass.git.blame",
933 "glass.git.conflicts",
934 "glass.git.stash.list",
935 "glass.git.worktree.list",
936 "glass.test.discover",
937 "glass.test.results",
938 "glass.eval.list",
939 "glass.lsp.diagnostics",
940 "glass.lsp.list",
941 "glass.lsp.events",
942 "glass.lsp.raw",
943 "glass.lsp.hover",
944 "glass.lsp.completion",
945 "glass.lsp.definition",
946 "glass.lsp.declaration",
947 "glass.lsp.implementation",
948 "glass.lsp.references",
949 "glass.lsp.document_symbols",
950 "glass.lsp.workspace_symbols",
951 "glass.lsp.signature_help",
952 "glass.lsp.code_actions",
953 "glass.lsp.formatting",
954 "glass.lsp.range_formatting",
955 "glass.lsp.semantic_tokens",
956 "glass.lsp.rename",
957 "glass.debug.stack",
958 "glass.debug.threads",
959 "glass.debug.scopes",
960 "glass.debug.variables",
961 "glass.debug.evaluate",
962 "glass.debug.events",
963 "glass.agent.list",
964 "glass.agent.messages",
965 "glass.agent.entries",
966 "glass.agent.stats",
967 "glass.graph.query",
968 "glass.graph.path",
969 "glass.graph.explain",
970 "glass.replay.list",
971 "glass.replay.inspect",
972 "glass.replay.diff",
973 "glass.editor.selection",
974 "glass.editor.diff",
975 "glass.editor.buffers",
976 "glass.process.health",
977 "glass.process.ports",
978 "glass.browser.state",
979 "glass.browser.observe",
980 "glass.browser.snapshot",
981 "glass.browser.semantic",
982 "glass.browser.diff",
983 "glass.browser.targets",
984 "glass.browser.screenshot",
985 "glass.workflow.list",
986 "glass.workflow.verify",
987 "glass.workflow.record",
988 "glass.memory.retrieve",
989 "glass.memory.explain",
990 "glass.semantic.inspect",
991 "glass.semantic.diff",
992 "glass.semantic.links",
993 ];
994 const MUTATE: &[&str] = &[
995 "glass.git.stage",
996 "glass.git.unstage",
997 "glass.git.commit",
998 "glass.git.branch.create",
999 "glass.git.branch.switch",
1000 "glass.git.stash.push",
1001 "glass.git.stash.pop",
1002 "glass.git.worktree.create",
1003 "glass.git.worktree.remove",
1004 "glass.test.run",
1005 "glass.test.run-affected",
1006 "glass.test.cancel",
1007 "glass.test.watch",
1008 "glass.eval.start",
1009 "glass.eval.execute",
1010 "glass.eval.reset",
1011 "glass.eval.stop",
1012 "glass.debug.start",
1013 "glass.lsp.start",
1014 "glass.lsp.stop",
1015 "glass.debug.launch",
1016 "glass.debug.attach",
1017 "glass.debug.configuration_done",
1018 "glass.debug.restart",
1019 "glass.debug.breakpoint.set",
1020 "glass.debug.breakpoint.remove",
1021 "glass.debug.exception.set",
1022 "glass.debug.continue",
1023 "glass.debug.pause",
1024 "glass.debug.step",
1025 "glass.debug.disconnect",
1026 "glass.debug.terminate",
1027 "glass.debug.stop",
1028 "glass.agent.spawn",
1029 "glass.agent.prompt",
1030 "glass.agent.steer",
1031 "glass.agent.follow-up",
1032 "glass.agent.abort",
1033 "glass.agent.compact",
1034 "glass.agent.model",
1035 "glass.agent.thinking",
1036 "glass.agent.new-session",
1037 "glass.agent.clone-session",
1038 "glass.agent.fork",
1039 "glass.agent.switch-session",
1040 "glass.agent.name",
1041 "glass.editor.open",
1042 "glass.editor.replace",
1043 "glass.editor.save",
1044 "glass.process.restart",
1045 "glass.process.input",
1046 "glass.process.resize",
1047 "glass.browser.start",
1048 "glass.browser.attach",
1049 "glass.browser.reconnect",
1050 "glass.browser.stop",
1051 "glass.browser.target.select",
1052 "glass.browser.navigate",
1053 "glass.browser.act",
1054 "glass.workflow.run",
1055 "glass.workflow.pause",
1056 "glass.workflow.resume",
1057 "glass.workflow.cancel",
1058 "glass.memory.forget",
1059 ];
1060 READ.iter()
1061 .map(|name| service_descriptor(name, false))
1062 .chain(MUTATE.iter().map(|name| service_descriptor(name, true)))
1063 .collect()
1064}
1065
1066fn service_descriptor(name: &str, mutating: bool) -> ToolDescriptor {
1067 ToolDescriptor {
1068 name: name.into(),
1069 description: format!("Resident Glass Dev operation {name}"),
1070 input_schema: serde_json::json!({"type":"object"}),
1071 mutating,
1072 available: true,
1073 unavailable_reason: None,
1074 }
1075}
1076
1077fn required_string<'a>(call: &'a ToolCall, name: &str) -> DevelopmentResult<&'a str> {
1078 call.arguments
1079 .get(name)
1080 .and_then(Value::as_str)
1081 .filter(|value| !value.is_empty() && value.len() <= 64 * 1024 && !value.contains('\0'))
1082 .ok_or_else(|| {
1083 DevelopmentError::InvalidInput(format!("{} requires bounded string {name}", call.name))
1084 })
1085}
1086
1087fn optional_string<'a>(call: &'a ToolCall, name: &str) -> Option<&'a str> {
1088 call.arguments.get(name).and_then(Value::as_str)
1089}
1090
1091fn required_value<'a>(call: &'a ToolCall, name: &str) -> DevelopmentResult<&'a Value> {
1092 call.arguments
1093 .get(name)
1094 .ok_or_else(|| DevelopmentError::InvalidInput(format!("{} requires {name}", call.name)))
1095}
1096
1097fn value_map(
1098 call: &ToolCall,
1099 name: &str,
1100) -> DevelopmentResult<std::collections::BTreeMap<String, Value>> {
1101 match call.arguments.get(name) {
1102 None => Ok(std::collections::BTreeMap::new()),
1103 Some(value) => serde_json::from_value(value.clone()).map_err(DevelopmentError::from),
1104 }
1105}
1106
1107fn boolean(call: &ToolCall, name: &str, default: bool) -> bool {
1108 call.arguments
1109 .get(name)
1110 .and_then(Value::as_bool)
1111 .unwrap_or(default)
1112}
1113
1114fn unsigned(call: &ToolCall, name: &str, default: u64) -> DevelopmentResult<u64> {
1115 let value = call
1116 .arguments
1117 .get(name)
1118 .and_then(Value::as_u64)
1119 .unwrap_or(default);
1120 (value <= i64::MAX as u64).then_some(value).ok_or_else(|| {
1121 DevelopmentError::InvalidInput(format!("{}.{} is out of range", call.name, name))
1122 })
1123}
1124
1125fn integer(call: &ToolCall, name: &str) -> DevelopmentResult<i64> {
1126 call.arguments
1127 .get(name)
1128 .and_then(Value::as_i64)
1129 .ok_or_else(|| DevelopmentError::InvalidInput(format!("{} requires {name}", call.name)))
1130}
1131
1132fn u32_value(call: &ToolCall, name: &str) -> DevelopmentResult<u32> {
1133 u32::try_from(unsigned(call, name, 0)?).map_err(|_| {
1134 DevelopmentError::InvalidInput(format!("{}.{} is out of range", call.name, name))
1135 })
1136}
1137
1138fn u16_value(call: &ToolCall, name: &str) -> DevelopmentResult<u16> {
1139 let value = u16::try_from(unsigned(call, name, 0)?).map_err(|_| {
1140 DevelopmentError::InvalidInput(format!("{}.{} is out of range", call.name, name))
1141 })?;
1142 (value > 0).then_some(value).ok_or_else(|| {
1143 DevelopmentError::InvalidInput(format!("{}.{} must be non-zero", call.name, name))
1144 })
1145}
1146
1147fn position(
1148 call: &ToolCall,
1149 name: &str,
1150) -> DevelopmentResult<glass_browser::development::DiagnosticPosition> {
1151 serde_json::from_value(required_value(call, name)?.clone()).map_err(DevelopmentError::from)
1152}
1153
1154fn value_array_or_empty(call: &ToolCall, name: &str) -> DevelopmentResult<Vec<Value>> {
1155 match call.arguments.get(name) {
1156 None => Ok(Vec::new()),
1157 Some(Value::Array(values)) if values.len() <= 512 => Ok(values.clone()),
1158 Some(_) => Err(DevelopmentError::InvalidInput(format!(
1159 "{}.{} must be an array of at most 512 values",
1160 call.name, name
1161 ))),
1162 }
1163}
1164
1165fn number(call: &ToolCall, name: &str, default: f64) -> DevelopmentResult<f64> {
1166 let value = call
1167 .arguments
1168 .get(name)
1169 .and_then(Value::as_f64)
1170 .unwrap_or(default);
1171 value.is_finite().then_some(value).ok_or_else(|| {
1172 DevelopmentError::InvalidInput(format!("{}.{} must be finite", call.name, name))
1173 })
1174}
1175
1176fn string_array(call: &ToolCall, name: &str) -> DevelopmentResult<Vec<String>> {
1177 let values = call
1178 .arguments
1179 .get(name)
1180 .and_then(Value::as_array)
1181 .filter(|values| !values.is_empty() && values.len() <= 256)
1182 .ok_or_else(|| DevelopmentError::InvalidInput(format!("{} requires {name}", call.name)))?;
1183 values
1184 .iter()
1185 .map(|value| {
1186 value
1187 .as_str()
1188 .filter(|value| !value.is_empty() && value.len() <= 4096 && !value.contains('\0'))
1189 .map(str::to_string)
1190 .ok_or_else(|| DevelopmentError::InvalidInput(format!("invalid {name} item")))
1191 })
1192 .collect()
1193}
1194
1195fn string_array_or_empty(call: &ToolCall, name: &str) -> DevelopmentResult<Vec<String>> {
1196 if call.arguments.get(name).is_none() {
1197 Ok(Vec::new())
1198 } else {
1199 string_array(call, name)
1200 }
1201}
1202
1203fn unsigned_array(call: &ToolCall, name: &str) -> DevelopmentResult<Vec<u64>> {
1204 call.arguments
1205 .get(name)
1206 .and_then(Value::as_array)
1207 .filter(|values| !values.is_empty() && values.len() <= 512)
1208 .ok_or_else(|| DevelopmentError::InvalidInput(format!("{} requires {name}", call.name)))?
1209 .iter()
1210 .map(|value| {
1211 value
1212 .as_u64()
1213 .filter(|value| *value > 0)
1214 .ok_or_else(|| DevelopmentError::InvalidInput(format!("invalid {name} item")))
1215 })
1216 .collect()
1217}
1218
1219fn timeout(call: &ToolCall, maximum_seconds: u64) -> DevelopmentResult<Option<Duration>> {
1220 call.arguments
1221 .get("timeoutSeconds")
1222 .map(|_| unsigned(call, "timeoutSeconds", maximum_seconds))
1223 .transpose()?
1224 .map(|seconds| {
1225 if seconds == 0 || seconds > maximum_seconds {
1226 Err(DevelopmentError::InvalidInput(format!(
1227 "timeoutSeconds must be 1..={maximum_seconds}"
1228 )))
1229 } else {
1230 Ok(Duration::from_secs(seconds))
1231 }
1232 })
1233 .transpose()
1234}
1235
1236fn parse_kernel_kind(value: &str) -> DevelopmentResult<KernelKind> {
1237 match value {
1238 "python" => Ok(KernelKind::Python),
1239 "javascript" => Ok(KernelKind::JavaScript),
1240 "shell" => Ok(KernelKind::Shell),
1241 "sql" => Ok(KernelKind::Sql),
1242 _ => Err(DevelopmentError::InvalidInput(
1243 "kernel kind must be python, javascript, shell, or sql".into(),
1244 )),
1245 }
1246}
1247
1248fn normalized_actor_id(value: &str) -> String {
1249 let normalized: String = value
1250 .chars()
1251 .filter(|character| character.is_ascii_alphanumeric() || "-_.".contains(*character))
1252 .take(128)
1253 .collect();
1254 if normalized.is_empty() {
1255 "actor".into()
1256 } else {
1257 normalized
1258 }
1259}
1260
1261fn agent_id(
1262 workspace: &mut DevelopmentWorkspace,
1263 value: &str,
1264) -> DevelopmentResult<crate::agents::AgentId> {
1265 workspace
1266 .agents()
1267 .list()?
1268 .into_iter()
1269 .find(|snapshot| snapshot.id.as_str() == value)
1270 .map(|snapshot| snapshot.id)
1271 .ok_or_else(|| DevelopmentError::NotFound(format!("agent {value}")))
1272}
1273
1274fn agent_request(
1275 workspace: &mut DevelopmentWorkspace,
1276 call: &ToolCall,
1277 request: HarnessRequest,
1278) -> DevelopmentResult<Value> {
1279 let id = agent_id(workspace, required_string(call, "agentId")?)?;
1280 map_service(workspace.agents().request(&id, request))?;
1281 Ok(serde_json::json!({"queued":true}))
1282}
1283
1284fn map_service<T: serde::Serialize, E: std::fmt::Display>(
1285 result: Result<T, E>,
1286) -> DevelopmentResult<Value> {
1287 result
1288 .map_err(|error| DevelopmentError::Process(error.to_string()))
1289 .and_then(|value| serde_json::to_value(value).map_err(DevelopmentError::from))
1290}
1291
1292fn map_debug<T: serde::Serialize>(
1293 result: crate::debugger::DebugResult<T>,
1294) -> DevelopmentResult<Value> {
1295 map_service(result)
1296}
1297
1298fn debugger<'a>(
1299 workspace: &'a mut DevelopmentWorkspace,
1300 name: &str,
1301) -> DevelopmentResult<&'a mut crate::debugger::DebuggerSession> {
1302 workspace
1303 .debugger_mut(name)
1304 .map_err(|error| DevelopmentError::Process(error.to_string()))
1305}
1306
1307fn git_value<T: serde::Serialize>(
1308 git: Option<&crate::git::GitService>,
1309 operation: impl FnOnce(&crate::git::GitService) -> crate::git::GitResult<T>,
1310) -> DevelopmentResult<Value> {
1311 map_service(operation(git.ok_or_else(|| {
1312 DevelopmentError::NotFound("Git repository".into())
1313 })?))
1314}
1315
1316fn git_mutation(
1317 git: Option<&crate::git::GitService>,
1318 operation: impl FnOnce(&crate::git::GitService) -> crate::git::GitResult<()>,
1319) -> DevelopmentResult<()> {
1320 operation(git.ok_or_else(|| DevelopmentError::NotFound("Git repository".into()))?)
1321 .map_err(|error| DevelopmentError::Process(error.to_string()))
1322}
1323
1324#[cfg(test)]
1325mod tests {
1326 use super::*;
1327 use glass_browser::development::Actor;
1328 use std::sync::atomic::{AtomicU64, Ordering};
1329
1330 static NEXT_ROOT: AtomicU64 = AtomicU64::new(0);
1331
1332 fn workspace() -> DevelopmentWorkspace {
1333 let sequence = NEXT_ROOT.fetch_add(1, Ordering::Relaxed);
1334 let root = std::env::temp_dir().join(format!(
1335 "glass-tool-router-{}-{sequence}",
1336 std::process::id()
1337 ));
1338 std::fs::create_dir_all(&root).unwrap();
1339 std::fs::write(
1340 root.join("Cargo.toml"),
1341 "[package]\nname='x'\nversion='0.1.0'\n",
1342 )
1343 .unwrap();
1344 DevelopmentWorkspace::open(root).unwrap()
1345 }
1346
1347 fn context(workspace: &DevelopmentWorkspace, mutate: bool) -> DevelopmentToolContext {
1348 DevelopmentToolContext {
1349 authorization: ToolAuthorization {
1350 actor: Actor::embedded(),
1351 allow_mutation: mutate,
1352 confirmed: mutate,
1353 },
1354 expected_generation: workspace.generation(),
1355 expected_project_revision: workspace.project().revision(),
1356 }
1357 }
1358
1359 #[test]
1360 fn router_rejects_stale_or_unauthorized_mutations() {
1361 let mut workspace = workspace();
1362 let router = DevelopmentToolRouter::default();
1363 let call = ToolCall {
1364 id: "write-1".into(),
1365 name: "glass.file.write".into(),
1366 arguments: serde_json::json!({"path":"src/lib.rs","content":"pub fn ok() {}\n"}),
1367 };
1368 let read_only = context(&workspace, false);
1369 assert!(router.execute(&mut workspace, &call, &read_only).is_err());
1370 let mut stale = context(&workspace, true);
1371 stale.expected_project_revision = stale.expected_project_revision.saturating_add(1);
1372 assert!(router.execute(&mut workspace, &call, &stale).is_err());
1373 let valid = context(&workspace, true);
1374 workspace.execute_tool(&call, &valid).unwrap();
1375 assert!(workspace.root().join("src/lib.rs").exists());
1376 let replay = workspace.intelligence().replay(0, 16).unwrap();
1377 assert_eq!(
1378 replay
1379 .iter()
1380 .map(|event| event.kind.as_str())
1381 .collect::<Vec<_>>(),
1382 vec!["called", "completed"]
1383 );
1384 assert!(
1385 workspace
1386 .intelligence()
1387 .path("repository:root", "tool:write-1")
1388 .is_ok()
1389 );
1390 }
1391
1392 #[test]
1393 fn router_uses_resident_kernel_and_test_services() {
1394 let mut workspace = workspace();
1395 let router = DevelopmentToolRouter::default();
1396 let start = ToolCall {
1397 id: "kernel-1".into(),
1398 name: "glass.eval.start".into(),
1399 arguments: serde_json::json!({"name":"analysis","kind":"sql"}),
1400 };
1401 let mutation = context(&workspace, true);
1402 router.execute(&mut workspace, &start, &mutation).unwrap();
1403 let execute = ToolCall {
1404 id: "kernel-2".into(),
1405 name: "glass.eval.execute".into(),
1406 arguments: serde_json::json!({"name":"analysis","code":"SELECT 40 + 2 AS answer"}),
1407 };
1408 let result = router.execute(&mut workspace, &execute, &mutation).unwrap();
1409 assert_eq!(result["value"][0]["answer"], 42);
1410 assert!(
1411 router
1412 .descriptors()
1413 .iter()
1414 .any(|descriptor| descriptor.name == "glass.debug.launch")
1415 );
1416 }
1417
1418 #[test]
1419 fn router_exposes_shared_editor_process_browser_and_complete_lsp_tools() {
1420 let mut workspace = workspace();
1421 std::fs::create_dir_all(workspace.root().join("src")).unwrap();
1422 std::fs::write(workspace.root().join("src/lib.rs"), "pub fn old() {}\n").unwrap();
1423 let router = DevelopmentToolRouter::default();
1424 let descriptors = router.descriptors();
1425 for name in [
1426 "glass.editor.open",
1427 "glass.editor.replace",
1428 "glass.editor.save",
1429 "glass.process.restart",
1430 "glass.process.input",
1431 "glass.process.resize",
1432 "glass.process.health",
1433 "glass.process.ports",
1434 "glass.browser.observe",
1435 "glass.browser.snapshot",
1436 "glass.browser.attach",
1437 "glass.browser.reconnect",
1438 "glass.browser.semantic",
1439 "glass.browser.diff",
1440 "glass.browser.navigate",
1441 "glass.browser.act",
1442 "glass.workflow.list",
1443 "glass.workflow.run",
1444 "glass.workflow.pause",
1445 "glass.workflow.resume",
1446 "glass.workflow.cancel",
1447 "glass.workflow.verify",
1448 "glass.workflow.record",
1449 "glass.memory.retrieve",
1450 "glass.memory.explain",
1451 "glass.memory.forget",
1452 "glass.semantic.inspect",
1453 "glass.semantic.diff",
1454 "glass.semantic.links",
1455 "glass.lsp.start",
1456 "glass.lsp.stop",
1457 "glass.lsp.list",
1458 "glass.lsp.events",
1459 "glass.lsp.definition",
1460 "glass.lsp.declaration",
1461 "glass.lsp.implementation",
1462 "glass.lsp.references",
1463 "glass.lsp.document_symbols",
1464 "glass.lsp.workspace_symbols",
1465 "glass.lsp.signature_help",
1466 "glass.lsp.code_actions",
1467 "glass.lsp.formatting",
1468 "glass.lsp.range_formatting",
1469 "glass.lsp.semantic_tokens",
1470 "glass.lsp.rename",
1471 "glass.lsp.raw",
1472 "glass.debug.configuration_done",
1473 "glass.debug.restart",
1474 "glass.debug.breakpoint.remove",
1475 "glass.debug.exception.set",
1476 "glass.debug.threads",
1477 "glass.debug.disconnect",
1478 "glass.debug.terminate",
1479 "glass.agent.model",
1480 "glass.agent.thinking",
1481 "glass.agent.new-session",
1482 "glass.agent.clone-session",
1483 "glass.agent.fork",
1484 "glass.agent.switch-session",
1485 "glass.agent.messages",
1486 "glass.agent.entries",
1487 "glass.agent.stats",
1488 "glass.agent.name",
1489 ] {
1490 let descriptor = descriptors
1491 .iter()
1492 .find(|descriptor| descriptor.name == name)
1493 .unwrap_or_else(|| panic!("missing {name}"));
1494 assert!(
1495 descriptor.available,
1496 "{name} must execute, not be a placeholder"
1497 );
1498 }
1499
1500 for (id, name, arguments) in [
1501 (
1502 "open",
1503 "glass.editor.open",
1504 serde_json::json!({"path":"src/lib.rs"}),
1505 ),
1506 (
1507 "replace",
1508 "glass.editor.replace",
1509 serde_json::json!({"path":"src/lib.rs","oldText":"old","newText":"resident"}),
1510 ),
1511 (
1512 "save",
1513 "glass.editor.save",
1514 serde_json::json!({"path":"src/lib.rs"}),
1515 ),
1516 ] {
1517 let call = ToolCall {
1518 id: id.into(),
1519 name: name.into(),
1520 arguments,
1521 };
1522 let authorized = context(&workspace, true);
1523 router.execute(&mut workspace, &call, &authorized).unwrap();
1524 }
1525 assert_eq!(
1526 std::fs::read_to_string(workspace.root().join("src/lib.rs")).unwrap(),
1527 "pub fn resident() {}\n"
1528 );
1529 }
1530}