1use super::{Actor, DevelopmentError, DevelopmentEventKind, DevelopmentResult, ProjectWorkspace};
2use serde::{Deserialize, Serialize};
3use serde_json::Value;
4use sha2::{Digest, Sha256};
5use std::{
6 collections::{BTreeSet, VecDeque},
7 io::{BufRead, BufReader, Write},
8 path::{Path, PathBuf},
9 process::{Child, ChildStdin, Command, Stdio},
10 sync::mpsc::{self, Receiver, RecvTimeoutError},
11 thread,
12 time::Duration,
13};
14
15const MAX_PI_EVENT_BYTES: usize = 512 * 1024;
16const MAX_PI_BUFFERED_EVENTS: usize = 64;
17const PI_EVENT_CHANNEL_CAPACITY: usize = 32;
18const PI_RESPONSE_TIMEOUT: Duration = Duration::from_secs(30);
19
20#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
21#[serde(rename_all = "camelCase")]
22pub struct ToolDescriptor {
23 pub name: String,
24 pub description: String,
25 pub input_schema: Value,
26 pub mutating: bool,
27 pub available: bool,
28 #[serde(default, skip_serializing_if = "Option::is_none")]
29 pub unavailable_reason: Option<String>,
30}
31
32#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
33#[serde(rename_all = "camelCase")]
34pub struct AgentContextPacket {
35 pub schema_version: String,
36 pub references: Vec<String>,
37 pub project: Value,
38 pub diagnostics: Value,
39 pub processes: Value,
40 pub recent_events: Value,
41 pub resolved: Value,
42 pub browser: Option<BrowserAgentContext>,
43 pub authority: AgentAuthorityContext,
44}
45
46#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
47#[serde(rename_all = "camelCase")]
48pub struct BrowserAgentContext {
49 pub connected: bool,
50 pub target_id: Option<String>,
51 pub origin: Option<String>,
52 pub url: String,
53 pub title: String,
54 pub browser_revision: u64,
55 pub semantic_summary: String,
56 pub semantic_entity_count: usize,
57 pub selected_entity: Option<Value>,
58 pub workflow_state: String,
59 pub input_owner: String,
60 pub freshness: String,
61 pub memory_scope: String,
62}
63
64#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
65#[serde(rename_all = "camelCase")]
66pub struct AgentAuthorityContext {
67 pub project_revision: u64,
68 pub browser_revision: Option<u64>,
69 pub mutation_lease_required: bool,
70 pub stale_context_rejected: bool,
71}
72
73pub fn resolve_context(
74 workspace: &mut ProjectWorkspace,
75 prompt: &str,
76) -> DevelopmentResult<AgentContextPacket> {
77 resolve_context_with_browser(workspace, prompt, None)
78}
79
80pub fn resolve_context_with_browser(
81 workspace: &mut ProjectWorkspace,
82 prompt: &str,
83 browser: Option<&BrowserAgentContext>,
84) -> DevelopmentResult<AgentContextPacket> {
85 if prompt.len() > 8 * 1024 {
86 return Err(DevelopmentError::InvalidInput(
87 "prompt exceeds the 8192 byte context limit".into(),
88 ));
89 }
90 let mut references = prompt
91 .split_whitespace()
92 .filter(|token| token.starts_with('@'))
93 .map(|token| {
94 token
95 .trim_matches(|character: char| {
96 matches!(character, ',' | '.' | '?' | '!' | ')' | ']')
97 })
98 .to_string()
99 })
100 .collect::<Vec<_>>();
101 references.sort();
102 references.dedup();
103 if references.len() > 32 {
104 return Err(DevelopmentError::InvalidInput(
105 "agent context cannot contain more than 32 references".into(),
106 ));
107 }
108 let mut resolved = serde_json::Map::new();
109 for reference in &references {
110 let value = match reference.as_str() {
111 "@workspace" => serde_json::to_value(workspace.detection())?,
112 "@diagnostic" => serde_json::to_value(workspace.diagnostics())?,
113 "@run:last" => workspace
114 .timeline()
115 .events()
116 .next_back()
117 .map(serde_json::to_value)
118 .transpose()?
119 .unwrap_or(Value::Null),
120 "@page" | "@browser" => browser.map(serde_json::to_value).transpose()?.unwrap_or_else(|| serde_json::json!({
121 "status": "requires-attached-browser-workspace", "defaultObservation": "structured"
122 })),
123 "@selection" => browser
124 .and_then(|value| value.selected_entity.clone())
125 .unwrap_or_else(|| serde_json::json!({"status": "not-selected"})),
126 "@file" | "@symbol" => serde_json::json!({"status": "not-selected"}),
127 value if value.starts_with("@entity:") => {
128 serde_json::to_value(workspace.graph().links_for(&value[8..]))?
129 }
130 value if value.starts_with("@file:") => {
131 let path = &value[6..];
132 let content = workspace.read_file(path)?;
133 serde_json::json!({"path": path, "bytes": content.len(), "sha256": prompt_evidence(&content)["sha256"]})
134 }
135 value if value.starts_with("@revision:") => {
136 let index = value[10..].parse::<usize>().map_err(|_| {
137 DevelopmentError::InvalidInput(format!("invalid revision reference: {value}"))
138 })?;
139 serde_json::to_value(workspace.replay(index, 1)?)?
140 }
141 "@workflow" => browser.map(|value| serde_json::json!({"state":value.workflow_state,"browserRevision":value.browser_revision})).unwrap_or_else(|| serde_json::json!({"status":"not-attached"})),
142 "@memory" => browser.map(|value| serde_json::json!({"scope":value.memory_scope,"authoritative":false})).unwrap_or_else(|| serde_json::json!({"status":"not-attached"})),
143 value => {
144 return Err(DevelopmentError::InvalidInput(format!(
145 "unsupported agent context reference: {value}"
146 )));
147 }
148 };
149 resolved.insert(reference.clone(), value);
150 }
151 let processes = workspace.processes().list_checked()?;
152 let events = workspace
153 .timeline()
154 .events()
155 .rev()
156 .take(32)
157 .collect::<Vec<_>>();
158 let project_revision = workspace.revision();
159 Ok(AgentContextPacket {
160 schema_version: "glass.agent-context.v1".into(),
161 references,
162 project: serde_json::to_value(workspace.detection())?,
163 diagnostics: serde_json::to_value(workspace.diagnostics())?,
164 processes: serde_json::to_value(processes)?,
165 recent_events: serde_json::to_value(events)?,
166 resolved: Value::Object(resolved),
167 browser: browser.cloned(),
168 authority: AgentAuthorityContext {
169 project_revision,
170 browser_revision: browser.map(|value| value.browser_revision),
171 mutation_lease_required: true,
172 stale_context_rejected: true,
173 },
174 })
175}
176
177#[derive(Debug, Clone, Default)]
178pub struct ToolRegistry;
179
180const MAX_TOOL_ARGUMENT_BYTES: usize = 256 * 1024;
181const MAX_TOOL_RESULT_BYTES: usize = 64 * 1024;
182const MAX_TOOL_CALL_ID_BYTES: usize = 128;
183const MAX_TOOL_NAME_BYTES: usize = 128;
184const MAX_GREP_FILES: usize = 512;
185const MAX_GREP_BYTES: u64 = 32 * 1024 * 1024;
186
187#[derive(Debug, Clone)]
188pub struct ToolAuthorization {
189 pub actor: Actor,
190 pub allow_mutation: bool,
191 pub confirmed: bool,
192}
193
194impl ToolAuthorization {
195 pub fn read_only(actor: Actor) -> Self {
196 Self {
197 actor,
198 allow_mutation: false,
199 confirmed: false,
200 }
201 }
202}
203
204#[derive(Debug, Clone)]
205pub struct AgentToolGateway {
206 registry: ToolRegistry,
207 descriptors: Vec<ToolDescriptor>,
208 browser_context: Option<BrowserAgentContext>,
209}
210
211impl Default for AgentToolGateway {
212 fn default() -> Self {
213 let registry = ToolRegistry;
214 let descriptors = registry.descriptors();
215 Self {
216 registry,
217 descriptors,
218 browser_context: None,
219 }
220 }
221}
222
223impl AgentToolGateway {
224 pub fn subprocess_broker() -> Self {
225 let mut gateway = Self::default();
226 for descriptor in &mut gateway.descriptors {
227 if matches!(
228 descriptor.name.as_str(),
229 "glass.process.start"
230 | "glass.process.stop"
231 | "glass.process.remove"
232 | "glass.process.logs"
233 | "glass.process.list"
234 ) {
235 descriptor.available = false;
236 descriptor.unavailable_reason =
237 Some("Requires a resident Glass Dev session that owns the managed PTY".into());
238 }
239 }
240 gateway
241 }
242
243 pub fn set_browser_context(&mut self, context: Option<BrowserAgentContext>) {
244 self.browser_context = context;
245 for descriptor in &mut self.descriptors {
246 let available = match descriptor.name.as_str() {
247 "glass.browser.observe" | "glass.memory.retrieve" => self
248 .browser_context
249 .as_ref()
250 .is_some_and(|value| value.connected),
251 "glass.workflow.pause" | "glass.workflow.resume" => self
252 .browser_context
253 .as_ref()
254 .is_some_and(|value| value.connected && value.workflow_state == "active"),
255 _ => continue,
256 };
257 descriptor.available = available;
258 descriptor.unavailable_reason = (!available).then(|| match descriptor.name.as_str() {
259 "glass.memory.retrieve" => {
260 "Requires an attached profile-scoped semantic memory store".into()
261 }
262 name if name.starts_with("glass.workflow") => {
263 "Requires an active browser workflow run".into()
264 }
265 _ => "Requires an attached Browser Workspace".into(),
266 });
267 }
268 }
269
270 pub fn descriptors(&self) -> Vec<ToolDescriptor> {
271 self.descriptors.clone()
272 }
273
274 pub fn execute(
275 &self,
276 workspace: &mut ProjectWorkspace,
277 call: &ToolCall,
278 authorization: &ToolAuthorization,
279 ) -> DevelopmentResult<Value> {
280 validate_tool_call_envelope(call)?;
281 let descriptor = self
282 .descriptors
283 .iter()
284 .find(|descriptor| descriptor.name == call.name)
285 .ok_or_else(|| DevelopmentError::NotFound(format!("tool {}", call.name)))?;
286 if !descriptor.available {
287 return Err(DevelopmentError::InvalidInput(
288 descriptor
289 .unavailable_reason
290 .clone()
291 .unwrap_or_else(|| format!("tool {} is unavailable", descriptor.name)),
292 ));
293 }
294 let argument_evidence = validate_tool_arguments(descriptor, &call.arguments)?;
295 if descriptor.mutating && (!authorization.allow_mutation || !authorization.confirmed) {
296 return Err(DevelopmentError::Conflict(format!(
297 "tool {} requires explicit mutation authority and confirmation",
298 descriptor.name
299 )));
300 }
301 workspace.record_as(
302 authorization.actor.clone(),
303 DevelopmentEventKind::AgentToolCalled,
304 tool_call_evidence(call, descriptor.mutating, &argument_evidence),
305 )?;
306 let result = if call.name == "glass.capabilities.inspect" {
307 Ok(serde_json::to_value(&self.descriptors)?)
308 } else {
309 self.execute_attached(call).unwrap_or_else(|| {
310 self.registry
311 .execute_unchecked(workspace, call, authorization.actor.clone())
312 })
313 };
314 let (ok, bytes) = match &result {
315 Ok(value) => {
316 let mut counter = BoundedJsonWriter::new(MAX_TOOL_RESULT_BYTES);
317 let serialized = serde_json::to_writer(&mut counter, value);
318 if counter.exceeded {
319 workspace.record_as(
320 authorization.actor.clone(),
321 DevelopmentEventKind::AgentToolResult,
322 serde_json::json!({"id": call.id, "name": call.name, "ok": false, "reason": "result-limit", "bytes": counter.bytes}),
323 )?;
324 return Err(DevelopmentError::InvalidInput(format!(
325 "tool result exceeds the {MAX_TOOL_RESULT_BYTES} byte limit"
326 )));
327 }
328 serialized?;
329 (true, counter.bytes)
330 }
331 Err(_) => (false, 0),
332 };
333 workspace.record_as(
334 authorization.actor.clone(),
335 DevelopmentEventKind::AgentToolResult,
336 serde_json::json!({"id": call.id, "name": call.name, "ok": ok, "bytes": bytes}),
337 )?;
338 result
339 }
340
341 fn execute_attached(&self, call: &ToolCall) -> Option<DevelopmentResult<Value>> {
342 let context = self.browser_context.as_ref()?;
343 match call.name.as_str() {
344 "glass.browser.observe" => Some(Ok(serde_json::json!({
345 "structured": true,
346 "targetId": context.target_id,
347 "origin": context.origin,
348 "url": context.url,
349 "title": context.title,
350 "browserRevision": context.browser_revision,
351 "semanticSummary": context.semantic_summary,
352 "semanticEntityCount": context.semantic_entity_count,
353 "selectedEntity": context.selected_entity,
354 "workflowState": context.workflow_state,
355 "inputOwner": context.input_owner,
356 "freshness": context.freshness,
357 }))),
358 "glass.memory.retrieve" => Some(Ok(serde_json::json!({
359 "scope": context.memory_scope,
360 "authoritative": false,
361 "requiresFreshSemanticEvidence": true
362 }))),
363 "glass.workflow.pause" | "glass.workflow.resume" => Some(Ok(serde_json::json!({
364 "workflowState": context.workflow_state,
365 "browserRevision": context.browser_revision,
366 "requiresMutationLease": true
367 }))),
368 _ => None,
369 }
370 }
371}
372
373impl ToolRegistry {
374 pub fn descriptors(&self) -> Vec<ToolDescriptor> {
375 let schema = |properties: Value, required: &[&str]| serde_json::json!({"type":"object", "properties": properties, "required": required, "additionalProperties": false});
376 vec![
377 descriptor(
378 "glass.file.read",
379 "Read one bounded project file",
380 schema(
381 serde_json::json!({"path":{"type":"string"},"offset":{"type":"integer"},"limit":{"type":"integer"}}),
382 &["path"],
383 ),
384 false,
385 ),
386 descriptor(
387 "glass.file.list",
388 "List bounded project files",
389 schema(
390 serde_json::json!({"path":{"type":"string"},"limit":{"type":"integer"}}),
391 &[],
392 ),
393 false,
394 ),
395 descriptor(
396 "glass.file.search",
397 "Search files, entities, processes, events, and commands",
398 schema(serde_json::json!({"query":{"type":"string"}}), &["query"]),
399 false,
400 ),
401 descriptor(
402 "glass.file.grep",
403 "Search bounded UTF-8 project files for a literal text pattern",
404 schema(
405 serde_json::json!({"pattern":{"type":"string"},"path":{"type":"string"},"glob":{"type":"string"},"ignoreCase":{"type":"boolean"},"context":{"type":"integer"},"limit":{"type":"integer"}}),
406 &["pattern"],
407 ),
408 false,
409 ),
410 descriptor(
411 "glass.file.find",
412 "Find bounded project paths with shell-style star and question-mark matching",
413 schema(
414 serde_json::json!({"pattern":{"type":"string"},"path":{"type":"string"},"limit":{"type":"integer"}}),
415 &["pattern"],
416 ),
417 false,
418 ),
419 descriptor(
420 "glass.file.patch",
421 "Replace bounded text through an attributed editor buffer",
422 schema(
423 serde_json::json!({"path":{"type":"string"},"search":{"type":"string"},"replace":{"type":"string"}}),
424 &["path", "search", "replace"],
425 ),
426 true,
427 ),
428 descriptor(
429 "glass.file.edit",
430 "Apply one atomic set of exact non-overlapping replacements",
431 schema(
432 serde_json::json!({"path":{"type":"string"},"edits":{"type":"array"}}),
433 &["path", "edits"],
434 ),
435 true,
436 ),
437 descriptor(
438 "glass.file.write",
439 "Create or replace one bounded project file",
440 schema(
441 serde_json::json!({"path":{"type":"string"},"content":{"type":"string"}}),
442 &["path", "content"],
443 ),
444 true,
445 ),
446 descriptor(
447 "glass.file.mkdir",
448 "Create one workspace-confined directory tree",
449 schema(serde_json::json!({"path":{"type":"string"}}), &["path"]),
450 true,
451 ),
452 descriptor(
453 "glass.file.rename",
454 "Rename one workspace-confined path",
455 schema(
456 serde_json::json!({"from":{"type":"string"},"to":{"type":"string"}}),
457 &["from", "to"],
458 ),
459 true,
460 ),
461 descriptor(
462 "glass.file.delete",
463 "Delete one file or empty directory",
464 schema(serde_json::json!({"path":{"type":"string"}}), &["path"]),
465 true,
466 ),
467 descriptor(
468 "glass.process.start",
469 "Start a named PTY process",
470 schema(
471 serde_json::json!({"name":{"type":"string"},"command":{"type":"string"}}),
472 &["name", "command"],
473 ),
474 true,
475 ),
476 descriptor(
477 "glass.process.stop",
478 "Stop a named managed process",
479 schema(serde_json::json!({"name":{"type":"string"}}), &["name"]),
480 true,
481 ),
482 descriptor(
483 "glass.process.remove",
484 "Remove a stopped managed process",
485 schema(serde_json::json!({"name":{"type":"string"}}), &["name"]),
486 true,
487 ),
488 descriptor(
489 "glass.neovim.probe",
490 "Probe the local Neovim PTY and RPC capabilities",
491 schema(serde_json::json!({}), &[]),
492 false,
493 ),
494 descriptor(
495 "glass.neovim.start",
496 "Start Neovim under Glass process ownership",
497 schema(
498 serde_json::json!({"name":{"type":"string"},"path":{"type":"string"}}),
499 &["name"],
500 ),
501 true,
502 ),
503 descriptor(
504 "glass.process.logs",
505 "Read a bounded managed-process output tail",
506 schema(serde_json::json!({"name":{"type":"string"}}), &["name"]),
507 false,
508 ),
509 descriptor(
510 "glass.process.list",
511 "List managed processes",
512 schema(serde_json::json!({}), &[]),
513 false,
514 ),
515 descriptor(
516 "glass.git.status",
517 "Inspect code and runtime impact",
518 schema(serde_json::json!({}), &[]),
519 false,
520 ),
521 descriptor(
522 "glass.semantic.inspect",
523 "Inspect source/runtime graph links",
524 schema(serde_json::json!({"entity":{"type":"string"}}), &["entity"]),
525 false,
526 ),
527 descriptor(
528 "glass.test.run",
529 "Run a command as attributed verification",
530 schema(
531 serde_json::json!({"name":{"type":"string"},"command":{"type":"string"}}),
532 &["name", "command"],
533 ),
534 true,
535 ),
536 descriptor(
537 "glass.command.run",
538 "Run one bounded command to completion as the Pi actor",
539 schema(
540 serde_json::json!({"name":{"type":"string"},"command":{"type":"string"},"timeoutSeconds":{"type":"integer"}}),
541 &["name", "command"],
542 ),
543 true,
544 ),
545 descriptor(
546 "glass.diagnostics.run",
547 "Publish bounded rust-analyzer diagnostics for one file",
548 schema(serde_json::json!({"path":{"type":"string"}}), &["path"]),
549 false,
550 ),
551 descriptor(
552 "glass.runtime.inspect",
553 "Inspect project, processes, actors, and diagnostics",
554 schema(serde_json::json!({}), &[]),
555 false,
556 ),
557 descriptor(
558 "glass.capabilities.inspect",
559 "Inspect the current Glass agent tool inventory and unavailable reasons",
560 schema(serde_json::json!({}), &[]),
561 false,
562 ),
563 descriptor(
564 "glass.web_ir.inspect",
565 "Validate and inspect one bounded Web IR document",
566 schema(serde_json::json!({"ir":{"type":"object"}}), &["ir"]),
567 false,
568 ),
569 descriptor(
570 "glass.web_ir.diff",
571 "Summarize a validated Web IR revision transition",
572 schema(
573 serde_json::json!({"before":{"type":"object"},"after":{"type":"object"}}),
574 &["before", "after"],
575 ),
576 false,
577 ),
578 descriptor(
579 "glass.web_ir.continuity",
580 "Classify graph-scoped entity continuity across two Web IR revisions",
581 schema(
582 serde_json::json!({"before":{"type":"object"},"after":{"type":"object"},"entityId":{"type":"string"}}),
583 &["before", "after", "entityId"],
584 ),
585 false,
586 ),
587 descriptor(
588 "glass.task.plan",
589 "Compile a value-free task and return a compact explanation",
590 schema(
591 serde_json::json!({"task":{"type":"object"},"ir":{"type":"object"}}),
592 &["task", "ir"],
593 ),
594 false,
595 ),
596 unavailable_descriptor(
597 "glass.browser.observe",
598 "Requires an attached Browser Workspace; structured observation remains the default",
599 ),
600 unavailable_descriptor(
601 "glass.browser.navigate",
602 "Requires an attached Browser Workspace and navigation policy",
603 ),
604 unavailable_descriptor(
605 "glass.browser.act",
606 "Requires an attached Browser Workspace and mutation lease",
607 ),
608 unavailable_descriptor(
609 "glass.workflow.pause",
610 "Requires an active browser workflow run",
611 ),
612 unavailable_descriptor(
613 "glass.workflow.resume",
614 "Requires an active browser workflow checkpoint",
615 ),
616 unavailable_descriptor(
617 "glass.memory.retrieve",
618 "Requires an attached profile-scoped semantic memory store",
619 ),
620 ]
621 }
622
623 fn execute_unchecked(
624 &self,
625 workspace: &mut ProjectWorkspace,
626 call: &ToolCall,
627 actor: Actor,
628 ) -> DevelopmentResult<Value> {
629 let string = |name: &str| {
630 call.arguments
631 .get(name)
632 .and_then(Value::as_str)
633 .ok_or_else(|| {
634 DevelopmentError::InvalidInput(format!(
635 "{} requires string argument {name}",
636 call.name
637 ))
638 })
639 };
640 match call.name.as_str() {
641 "glass.file.read" => read_tool_file(workspace, call, string("path")?),
642 "glass.file.list" => list_tool_files(workspace, call),
643 "glass.file.search" => Ok(serde_json::to_value(
644 workspace.search(string("query")?, 64)?,
645 )?),
646 "glass.file.grep" => grep_tool_files(workspace, call, string("pattern")?),
647 "glass.file.find" => find_tool_files(workspace, call, string("pattern")?),
648 "glass.file.patch" => {
649 let count = workspace.replace_in_buffer(
650 string("path")?,
651 string("search")?,
652 string("replace")?,
653 actor,
654 )?;
655 if count == 0 {
656 return Err(DevelopmentError::Conflict(
657 "patch search text was not found".into(),
658 ));
659 }
660 let path = string("path")?.to_string();
661 let buffer = workspace.save_buffer(&path)?;
662 Ok(serde_json::json!({"path": path, "replacements": count, "dirty": buffer.dirty}))
663 }
664 "glass.file.edit" => execute_atomic_edits(workspace, call, actor),
665 "glass.file.write" => {
666 let path = string("path")?.to_string();
667 workspace.write_file(&path, string("content")?, actor)?;
668 Ok(serde_json::json!({"path":path,"written":true}))
669 }
670 "glass.file.mkdir" => {
671 let path = string("path")?.to_string();
672 workspace.create_directory(&path, actor)?;
673 Ok(serde_json::json!({"path":path,"created":true}))
674 }
675 "glass.file.rename" => {
676 let from = string("from")?.to_string();
677 let to = string("to")?.to_string();
678 workspace.rename_path(&from, &to, actor)?;
679 Ok(serde_json::json!({"from":from,"to":to,"renamed":true}))
680 }
681 "glass.neovim.probe" => Ok(serde_json::to_value(super::probe_neovim()?)?),
682 "glass.neovim.start" => Ok(serde_json::to_value(super::start_neovim(
683 workspace.processes(),
684 string("name")?,
685 call.arguments
686 .get("path")
687 .and_then(Value::as_str)
688 .map(std::path::Path::new),
689 )?)?),
690 "glass.file.delete" => {
691 let path = string("path")?.to_string();
692 workspace.delete_path(&path, actor)?;
693 Ok(serde_json::json!({"path":path,"deleted":true}))
694 }
695 "glass.process.start" => Ok(serde_json::to_value(
696 workspace.start_process(string("name")?, string("command")?)?,
697 )?),
698 "glass.process.stop" => Ok(serde_json::to_value(
699 workspace.stop_process(string("name")?)?,
700 )?),
701 "glass.process.remove" => Ok(serde_json::to_value(
702 workspace.processes().remove(string("name")?)?,
703 )?),
704 "glass.process.logs" => {
705 Ok(serde_json::json!({"output": workspace.processes().output(string("name")?)?}))
706 }
707 "glass.process.list" => {
708 Ok(serde_json::to_value(workspace.processes().list_checked()?)?)
709 }
710 "glass.git.status" => Ok(serde_json::to_value(workspace.diff()?)?),
711 "glass.semantic.inspect" => Ok(serde_json::to_value(
712 workspace.graph().links_for(string("entity")?),
713 )?),
714 "glass.test.run" => Ok(serde_json::to_value(workspace.run_verification(
715 string("name")?,
716 string("command")?,
717 Duration::from_secs(120),
718 )?)?),
719 "glass.command.run" => {
720 let timeout = call
721 .arguments
722 .get("timeoutSeconds")
723 .and_then(Value::as_u64)
724 .unwrap_or(120);
725 if !(1..=300).contains(&timeout) {
726 return Err(DevelopmentError::InvalidInput(
727 "glass.command.run timeoutSeconds must be between 1 and 300".into(),
728 ));
729 }
730 Ok(serde_json::to_value(workspace.run_command_to_completion(
731 string("name")?,
732 string("command")?,
733 Duration::from_secs(timeout),
734 )?)?)
735 }
736 "glass.diagnostics.run" => Ok(serde_json::to_value(
737 workspace.publish_rust_diagnostics(string("path")?)?,
738 )?),
739 "glass.runtime.inspect" => Ok(serde_json::json!({
740 "project": workspace.detection(),
741 "processes": workspace.processes().list_checked()?,
742 "actors": workspace.actors().collect::<Vec<_>>(),
743 "diagnostics": workspace.diagnostics(),
744 "revision": workspace.revision()
745 })),
746 "glass.web_ir.inspect" => {
747 let ir: glass_browser::web_ir::GlassWebIrV1 =
748 serde_json::from_value(call.arguments["ir"].clone())?;
749 ir.validate().map_err(|error| {
750 DevelopmentError::InvalidInput(format!("invalid Web IR: {error}"))
751 })?;
752 Ok(serde_json::to_value(
753 glass_browser::protocol::WebIrInspectionResult::from_ir(&ir),
754 )?)
755 }
756 "glass.web_ir.diff" => {
757 let before: glass_browser::web_ir::GlassWebIrV1 =
758 serde_json::from_value(call.arguments["before"].clone())?;
759 let after: glass_browser::web_ir::GlassWebIrV1 =
760 serde_json::from_value(call.arguments["after"].clone())?;
761 let diff = before.diff(&after).map_err(|error| {
762 DevelopmentError::InvalidInput(format!("invalid Web IR transition: {error}"))
763 })?;
764 Ok(serde_json::json!({
765 "fromRevision": diff.from_revision,
766 "toRevision": diff.to_revision,
767 "entityChanges": diff.entity_changes.len(),
768 "relationshipChanges": diff.relationship_changes.len(),
769 "coverageChanged": diff.coverage_changed,
770 "limitsChanged": diff.limits_changed
771 }))
772 }
773 "glass.web_ir.continuity" => {
774 let before: glass_browser::web_ir::GlassWebIrV1 =
775 serde_json::from_value(call.arguments["before"].clone())?;
776 let after: glass_browser::web_ir::GlassWebIrV1 =
777 serde_json::from_value(call.arguments["after"].clone())?;
778 let entity_id = string("entityId")?;
779 Ok(serde_json::to_value(
780 before
781 .classify_entity_continuity(&after, entity_id)
782 .map_err(|error| {
783 DevelopmentError::InvalidInput(format!(
784 "invalid Web IR transition: {error}"
785 ))
786 })?,
787 )?)
788 }
789 "glass.task.plan" => {
790 let task: glass_browser::task_protocol::GlassTask =
791 serde_json::from_value(call.arguments["task"].clone())?;
792 let ir: glass_browser::web_ir::GlassWebIrV1 =
793 serde_json::from_value(call.arguments["ir"].clone())?;
794 let plan =
795 glass_browser::task_compiler::compile_task(&task, &ir).map_err(|error| {
796 DevelopmentError::InvalidInput(format!("task compilation failed: {error}"))
797 })?;
798 Ok(serde_json::json!({
799 "sourceRevision": plan.source_ir_revision,
800 "task": plan.task,
801 "risk": plan.risk,
802 "confirmationRequired": plan.confirmation_required,
803 "selectedEntityIds": plan.selected_entity_ids,
804 "requiredRuntimeCapabilities": plan.required_runtime_capabilities,
805 "entityEvidenceRequirements": plan.entity_evidence_requirements,
806 "steps": plan.steps,
807 "postconditions": plan.postconditions
808 }))
809 }
810 _ => Err(DevelopmentError::NotFound(format!("tool {}", call.name))),
811 }
812 }
813}
814
815struct ToolArgumentEvidence {
816 bytes: usize,
817 sha256: String,
818}
819
820struct BoundedJsonWriter {
821 limit: usize,
822 bytes: usize,
823 exceeded: bool,
824 digest: Sha256,
825}
826
827impl BoundedJsonWriter {
828 fn new(limit: usize) -> Self {
829 Self {
830 limit,
831 bytes: 0,
832 exceeded: false,
833 digest: Sha256::new(),
834 }
835 }
836
837 fn evidence(self) -> ToolArgumentEvidence {
838 let digest = self.digest.finalize();
839 ToolArgumentEvidence {
840 bytes: self.bytes,
841 sha256: digest_hex(&digest),
842 }
843 }
844}
845
846impl Write for BoundedJsonWriter {
847 fn write(&mut self, buffer: &[u8]) -> std::io::Result<usize> {
848 let remaining = self.limit.saturating_sub(self.bytes);
849 if buffer.len() > remaining {
850 self.bytes = self.bytes.saturating_add(buffer.len());
851 self.exceeded = true;
852 return Err(std::io::Error::other("bounded JSON limit exceeded"));
853 }
854 self.bytes += buffer.len();
855 self.digest.update(buffer);
856 Ok(buffer.len())
857 }
858
859 fn flush(&mut self) -> std::io::Result<()> {
860 Ok(())
861 }
862}
863
864fn read_tool_file(
865 workspace: &mut ProjectWorkspace,
866 call: &ToolCall,
867 path: &str,
868) -> DevelopmentResult<Value> {
869 let content = workspace.read_file(path)?;
870 let content_sha256 = digest_hex(&Sha256::digest(content.as_bytes()));
871 let offset = call
872 .arguments
873 .get("offset")
874 .and_then(Value::as_u64)
875 .unwrap_or(1);
876 let limit = call
877 .arguments
878 .get("limit")
879 .and_then(Value::as_u64)
880 .unwrap_or(500);
881 if offset == 0 || !(1..=2_000).contains(&limit) {
882 return Err(DevelopmentError::InvalidInput(
883 "glass.file.read offset must be positive and limit must be between 1 and 2000".into(),
884 ));
885 }
886 let total_lines = content
887 .lines()
888 .count()
889 .max(usize::from(!content.is_empty())) as u64;
890 let mut selected = content
891 .split_inclusive('\n')
892 .skip(offset.saturating_sub(1) as usize)
893 .take(limit as usize)
894 .collect::<String>();
895 let selected_lines = selected.lines().count() as u64;
896 let mut bytes_truncated = false;
897 if selected.len() > 60 * 1024 {
898 let mut boundary = 60 * 1024;
899 while !selected.is_char_boundary(boundary) {
900 boundary -= 1;
901 }
902 selected.truncate(boundary);
903 bytes_truncated = true;
904 }
905 Ok(serde_json::json!({
906 "path": path,
907 "content": selected,
908 "offset": offset,
909 "lines": selected_lines,
910 "totalLines": total_lines,
911 "sha256": content_sha256,
912 "truncated": bytes_truncated || offset.saturating_sub(1) + selected_lines < total_lines,
913 }))
914}
915
916fn list_tool_files(workspace: &ProjectWorkspace, call: &ToolCall) -> DevelopmentResult<Value> {
917 let path_prefix = optional_string_argument(call, "path")
918 .map(|path| path.trim_matches('/').to_string())
919 .unwrap_or_default();
920 let limit = bounded_u64_argument(call, "limit", 1, 2_000, 500)? as usize;
921 let tree = workspace.list_files_result()?;
922 let mut entries = Vec::new();
923 let mut truncated = tree.truncated;
924 for entry in tree.entries {
925 if !path_prefix.is_empty()
926 && entry.path != path_prefix
927 && !entry.path.starts_with(&format!("{path_prefix}/"))
928 {
929 continue;
930 }
931 entries.push(entry);
932 if entries.len() == limit {
933 truncated = true;
934 break;
935 }
936 }
937 Ok(serde_json::json!({
938 "entries": entries,
939 "limit": limit,
940 "truncated": truncated,
941 "ignoredDirectories": tree.ignored_directories,
942 "skippedSymlinks": tree.skipped_symlinks,
943 }))
944}
945
946fn grep_tool_files(
947 workspace: &mut ProjectWorkspace,
948 call: &ToolCall,
949 pattern: &str,
950) -> DevelopmentResult<Value> {
951 if pattern.is_empty() {
952 return Err(DevelopmentError::InvalidInput(
953 "glass.file.grep pattern must not be empty".into(),
954 ));
955 }
956 let path_prefix = optional_string_argument(call, "path")
957 .map(|path| path.trim_matches('/').to_string())
958 .unwrap_or_default();
959 let glob = optional_string_argument(call, "glob");
960 let ignore_case = call
961 .arguments
962 .get("ignoreCase")
963 .and_then(Value::as_bool)
964 .unwrap_or(false);
965 let context = bounded_u64_argument(call, "context", 0, 10, 0)? as usize;
966 let limit = bounded_u64_argument(call, "limit", 1, 500, 100)? as usize;
967 let needle = ignore_case.then(|| pattern.to_lowercase());
968 let entries = workspace.list_files_result()?;
969 let mut matches = Vec::new();
970 let mut files_searched = 0usize;
971 let mut bytes_searched = 0u64;
972 let mut files_skipped = 0usize;
973 let mut truncated = entries.truncated;
974 for entry in entries.entries {
975 if entry.kind != super::project::FileKind::File
976 || (!path_prefix.is_empty()
977 && entry.path != path_prefix
978 && !entry.path.starts_with(&format!("{path_prefix}/")))
979 || glob.is_some_and(|glob| !wildcard_matches(glob, &entry.path))
980 {
981 continue;
982 }
983 let bytes = entry.bytes.unwrap_or(0);
984 if files_searched == MAX_GREP_FILES || bytes_searched.saturating_add(bytes) > MAX_GREP_BYTES
985 {
986 truncated = true;
987 break;
988 }
989 let Ok(content) = workspace.read_file_snapshot(&entry.path) else {
990 files_skipped += 1;
991 continue;
992 };
993 files_searched += 1;
994 bytes_searched = bytes_searched.saturating_add(content.len() as u64);
995 let lines = content.lines().collect::<Vec<_>>();
996 for (index, line) in lines.iter().enumerate() {
997 let found = needle.as_ref().map_or_else(
998 || line.contains(pattern),
999 |needle| line.to_lowercase().contains(needle),
1000 );
1001 if !found {
1002 continue;
1003 }
1004 let start = index.saturating_sub(context);
1005 let end = (index + context + 1).min(lines.len());
1006 matches.push(serde_json::json!({
1007 "path": entry.path,
1008 "line": index + 1,
1009 "text": line,
1010 "contextBefore": lines[start..index],
1011 "contextAfter": lines[index + 1..end],
1012 }));
1013 if matches.len() == limit {
1014 return Ok(serde_json::json!({
1015 "matches": matches,
1016 "filesSearched": files_searched,
1017 "bytesSearched": bytes_searched,
1018 "filesSkipped": files_skipped,
1019 "limit": limit,
1020 "truncated": true,
1021 "literal": true,
1022 }));
1023 }
1024 }
1025 }
1026 Ok(serde_json::json!({
1027 "matches": matches,
1028 "filesSearched": files_searched,
1029 "bytesSearched": bytes_searched,
1030 "filesSkipped": files_skipped,
1031 "limit": limit,
1032 "truncated": truncated,
1033 "literal": true,
1034 }))
1035}
1036
1037fn find_tool_files(
1038 workspace: &ProjectWorkspace,
1039 call: &ToolCall,
1040 pattern: &str,
1041) -> DevelopmentResult<Value> {
1042 if pattern.is_empty() {
1043 return Err(DevelopmentError::InvalidInput(
1044 "glass.file.find pattern must not be empty".into(),
1045 ));
1046 }
1047 let path_prefix = optional_string_argument(call, "path")
1048 .map(|path| path.trim_matches('/').to_string())
1049 .unwrap_or_default();
1050 let limit = bounded_u64_argument(call, "limit", 1, 2_000, 500)? as usize;
1051 let tree = workspace.list_files_result()?;
1052 let mut paths = Vec::new();
1053 let mut truncated = tree.truncated;
1054 for entry in tree.entries {
1055 if (!path_prefix.is_empty()
1056 && entry.path != path_prefix
1057 && !entry.path.starts_with(&format!("{path_prefix}/")))
1058 || !wildcard_matches(pattern, &entry.path)
1059 {
1060 continue;
1061 }
1062 paths.push(serde_json::json!({"path":entry.path,"kind":entry.kind}));
1063 if paths.len() == limit {
1064 truncated = true;
1065 break;
1066 }
1067 }
1068 Ok(serde_json::json!({"paths":paths,"limit":limit,"truncated":truncated}))
1069}
1070
1071fn optional_string_argument<'a>(call: &'a ToolCall, name: &str) -> Option<&'a str> {
1072 call.arguments.get(name).and_then(Value::as_str)
1073}
1074
1075fn bounded_u64_argument(
1076 call: &ToolCall,
1077 name: &str,
1078 minimum: u64,
1079 maximum: u64,
1080 default: u64,
1081) -> DevelopmentResult<u64> {
1082 let value = call
1083 .arguments
1084 .get(name)
1085 .and_then(Value::as_u64)
1086 .unwrap_or(default);
1087 if !(minimum..=maximum).contains(&value) {
1088 return Err(DevelopmentError::InvalidInput(format!(
1089 "{} {name} must be between {minimum} and {maximum}",
1090 call.name
1091 )));
1092 }
1093 Ok(value)
1094}
1095
1096fn wildcard_matches(pattern: &str, value: &str) -> bool {
1097 let pattern = pattern.chars().collect::<Vec<_>>();
1098 let value = value.chars().collect::<Vec<_>>();
1099 let (mut pattern_index, mut value_index) = (0usize, 0usize);
1100 let (mut star, mut retry) = (None, 0usize);
1101 while value_index < value.len() {
1102 if pattern_index < pattern.len()
1103 && (pattern[pattern_index] == '?' || pattern[pattern_index] == value[value_index])
1104 {
1105 pattern_index += 1;
1106 value_index += 1;
1107 } else if pattern_index < pattern.len() && pattern[pattern_index] == '*' {
1108 star = Some(pattern_index);
1109 pattern_index += 1;
1110 retry = value_index;
1111 } else if let Some(star_index) = star {
1112 pattern_index = star_index + 1;
1113 retry += 1;
1114 value_index = retry;
1115 } else {
1116 return false;
1117 }
1118 }
1119 while pattern_index < pattern.len() && pattern[pattern_index] == '*' {
1120 pattern_index += 1;
1121 }
1122 pattern_index == pattern.len()
1123}
1124
1125fn execute_atomic_edits(
1126 workspace: &mut ProjectWorkspace,
1127 call: &ToolCall,
1128 actor: Actor,
1129) -> DevelopmentResult<Value> {
1130 let path = call.arguments["path"]
1131 .as_str()
1132 .ok_or_else(|| DevelopmentError::InvalidInput("glass.file.edit requires path".into()))?;
1133 let edits = call.arguments["edits"]
1134 .as_array()
1135 .filter(|edits| !edits.is_empty() && edits.len() <= 64)
1136 .ok_or_else(|| {
1137 DevelopmentError::InvalidInput("glass.file.edit requires between 1 and 64 edits".into())
1138 })?;
1139 let original = workspace.read_file(path)?;
1140 let mut replacements = Vec::with_capacity(edits.len());
1141 for edit in edits {
1142 let old_text = edit.get("oldText").and_then(Value::as_str).ok_or_else(|| {
1143 DevelopmentError::InvalidInput("every edit requires string oldText".into())
1144 })?;
1145 let new_text = edit.get("newText").and_then(Value::as_str).ok_or_else(|| {
1146 DevelopmentError::InvalidInput("every edit requires string newText".into())
1147 })?;
1148 if old_text.is_empty() {
1149 return Err(DevelopmentError::InvalidInput(
1150 "glass.file.edit oldText must not be empty".into(),
1151 ));
1152 }
1153 let matches = original.match_indices(old_text).collect::<Vec<_>>();
1154 if matches.len() != 1 {
1155 return Err(DevelopmentError::Conflict(format!(
1156 "glass.file.edit oldText must match exactly once; matched {} times",
1157 matches.len()
1158 )));
1159 }
1160 let start = matches[0].0;
1161 replacements.push((start, start + old_text.len(), new_text));
1162 }
1163 replacements.sort_by_key(|replacement| replacement.0);
1164 if replacements.windows(2).any(|pair| pair[0].1 > pair[1].0) {
1165 return Err(DevelopmentError::Conflict(
1166 "glass.file.edit replacements overlap".into(),
1167 ));
1168 }
1169 let mut content = original;
1170 for (start, end, new_text) in replacements.iter().rev() {
1171 content.replace_range(*start..*end, new_text);
1172 }
1173 workspace.edit_buffer(path, content, actor)?;
1174 let buffer = workspace.save_buffer(path)?;
1175 Ok(serde_json::json!({
1176 "path": path,
1177 "replacements": replacements.len(),
1178 "dirty": buffer.dirty,
1179 }))
1180}
1181
1182fn validate_tool_call_envelope(call: &ToolCall) -> DevelopmentResult<()> {
1183 if call.id.is_empty()
1184 || call.id.len() > MAX_TOOL_CALL_ID_BYTES
1185 || call.id.chars().any(char::is_control)
1186 {
1187 return Err(DevelopmentError::InvalidInput(format!(
1188 "tool call id must contain 1 to {MAX_TOOL_CALL_ID_BYTES} non-control bytes"
1189 )));
1190 }
1191 if call.name.is_empty()
1192 || call.name.len() > MAX_TOOL_NAME_BYTES
1193 || !call
1194 .name
1195 .bytes()
1196 .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'.' | b'_' | b'-'))
1197 {
1198 return Err(DevelopmentError::InvalidInput(format!(
1199 "tool name must contain 1 to {MAX_TOOL_NAME_BYTES} ASCII identifier bytes"
1200 )));
1201 }
1202 Ok(())
1203}
1204
1205fn validate_tool_arguments(
1206 descriptor: &ToolDescriptor,
1207 arguments: &Value,
1208) -> DevelopmentResult<ToolArgumentEvidence> {
1209 let mut writer = BoundedJsonWriter::new(MAX_TOOL_ARGUMENT_BYTES);
1210 let serialized = serde_json::to_writer(&mut writer, arguments);
1211 if writer.exceeded {
1212 return Err(DevelopmentError::InvalidInput(format!(
1213 "tool arguments exceed the {MAX_TOOL_ARGUMENT_BYTES} byte limit"
1214 )));
1215 }
1216 serialized?;
1217 let object = arguments.as_object().ok_or_else(|| {
1218 DevelopmentError::InvalidInput(format!("{} arguments must be an object", descriptor.name))
1219 })?;
1220 let properties = descriptor.input_schema["properties"]
1221 .as_object()
1222 .cloned()
1223 .unwrap_or_default();
1224 for required in descriptor.input_schema["required"]
1225 .as_array()
1226 .into_iter()
1227 .flatten()
1228 .filter_map(Value::as_str)
1229 {
1230 if !object.contains_key(required) {
1231 return Err(DevelopmentError::InvalidInput(format!(
1232 "{} requires argument {required}",
1233 descriptor.name
1234 )));
1235 }
1236 }
1237 for (name, value) in object {
1238 let Some(property) = properties.get(name) else {
1239 return Err(DevelopmentError::InvalidInput(format!(
1240 "{} does not accept argument {name}",
1241 descriptor.name
1242 )));
1243 };
1244 let valid = match property["type"].as_str() {
1245 Some("string") => value.is_string(),
1246 Some("object") => value.is_object(),
1247 Some("integer") => value.as_u64().is_some(),
1248 _ => true,
1249 };
1250 if !valid {
1251 return Err(DevelopmentError::InvalidInput(format!(
1252 "{}.{} has the wrong type",
1253 descriptor.name, name
1254 )));
1255 }
1256 }
1257 Ok(writer.evidence())
1258}
1259
1260fn tool_call_evidence(call: &ToolCall, mutating: bool, evidence: &ToolArgumentEvidence) -> Value {
1261 serde_json::json!({
1262 "id": call.id,
1263 "name": call.name,
1264 "mutating": mutating,
1265 "argumentBytes": evidence.bytes,
1266 "argumentSha256": evidence.sha256
1267 })
1268}
1269
1270fn digest_hex(bytes: &[u8]) -> String {
1271 const DIGITS: &[u8; 16] = b"0123456789abcdef";
1272 let mut encoded = String::with_capacity(bytes.len() * 2);
1273 for byte in bytes {
1274 encoded.push(DIGITS[(byte >> 4) as usize] as char);
1275 encoded.push(DIGITS[(byte & 0x0f) as usize] as char);
1276 }
1277 encoded
1278}
1279
1280fn descriptor(
1281 name: &str,
1282 description: &str,
1283 input_schema: Value,
1284 mutating: bool,
1285) -> ToolDescriptor {
1286 ToolDescriptor {
1287 name: name.into(),
1288 description: description.into(),
1289 input_schema,
1290 mutating,
1291 available: true,
1292 unavailable_reason: None,
1293 }
1294}
1295
1296fn unavailable_descriptor(name: &str, reason: &str) -> ToolDescriptor {
1297 ToolDescriptor {
1298 name: name.into(),
1299 description: reason.into(),
1300 input_schema: serde_json::json!({"type":"object"}),
1301 mutating: false,
1302 available: false,
1303 unavailable_reason: Some(reason.into()),
1304 }
1305}
1306
1307#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1308#[serde(tag = "type", rename_all = "camelCase")]
1309pub enum HarnessRequest {
1310 Hello,
1311 Prompt { text: String },
1312 Steer { text: String },
1313 FollowUp { text: String },
1314 Abort,
1315 State,
1316 Models,
1317 SetModel { provider: String, model_id: String },
1318 SetThinking { level: String },
1319 NewSession,
1320 Compact { instructions: Option<String> },
1321 CloneSession,
1322 Fork { entry_id: String },
1323 SwitchSession { path: String },
1324 Entries { since: Option<String> },
1325 Messages,
1326 SessionStats,
1327 SetSessionName { name: String },
1328}
1329
1330#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1331#[serde(tag = "type", rename_all = "camelCase")]
1332pub enum HarnessEvent {
1333 Hello {
1334 protocol: String,
1335 actor: Actor,
1336 capabilities: Vec<String>,
1337 },
1338 State {
1339 state: String,
1340 },
1341 Text {
1342 text: String,
1343 },
1344 ToolCall(ToolCall),
1345 ToolResult {
1346 id: String,
1347 result: Value,
1348 },
1349 Error {
1350 message: String,
1351 },
1352}
1353
1354#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1355#[serde(rename_all = "camelCase")]
1356pub struct ToolCall {
1357 pub id: String,
1358 pub name: String,
1359 pub arguments: Value,
1360}
1361
1362#[derive(Debug, Clone)]
1363pub struct LocalHarness {
1364 actor: Actor,
1365 gateway: AgentToolGateway,
1366 next_tool_id: u64,
1367 state: String,
1368 browser_context: Option<BrowserAgentContext>,
1369}
1370
1371impl Default for LocalHarness {
1372 fn default() -> Self {
1373 Self {
1374 actor: Actor::embedded(),
1375 gateway: AgentToolGateway::default(),
1376 next_tool_id: 1,
1377 state: "idle".into(),
1378 browser_context: None,
1379 }
1380 }
1381}
1382
1383impl LocalHarness {
1384 pub fn set_browser_context(&mut self, context: Option<BrowserAgentContext>) {
1385 self.browser_context = context.clone();
1386 self.gateway.set_browser_context(context);
1387 }
1388 pub fn actor(&self) -> &Actor {
1389 &self.actor
1390 }
1391
1392 pub fn handle(
1393 &mut self,
1394 workspace: &mut ProjectWorkspace,
1395 request: HarnessRequest,
1396 ) -> DevelopmentResult<Vec<HarnessEvent>> {
1397 match request {
1398 HarnessRequest::Hello => Ok(vec![HarnessEvent::Hello {
1399 protocol: "glass.harness.v1".into(),
1400 actor: self.actor.clone(),
1401 capabilities: vec![
1402 "prompt".into(),
1403 "stream".into(),
1404 "tool.call".into(),
1405 "steer".into(),
1406 "follow_up".into(),
1407 "abort".into(),
1408 "session.new".into(),
1409 "model.list".into(),
1410 ],
1411 }]),
1412 HarnessRequest::Prompt { text } => self.prompt(workspace, text),
1413 HarnessRequest::Steer { text } => {
1414 let evidence = prompt_evidence(&text);
1415 workspace.record_as(
1416 self.actor.clone(),
1417 DevelopmentEventKind::AgentSteered,
1418 evidence,
1419 )?;
1420 self.state = "steered".into();
1421 Ok(vec![
1422 HarnessEvent::State {
1423 state: self.state.clone(),
1424 },
1425 HarnessEvent::Text {
1426 text: "Steering accepted by the Glass harness.".into(),
1427 },
1428 ])
1429 }
1430 HarnessRequest::Abort => {
1431 self.state = "aborted".into();
1432 Ok(vec![HarnessEvent::State {
1433 state: self.state.clone(),
1434 }])
1435 }
1436 HarnessRequest::FollowUp { text } => self.prompt(workspace, text),
1437 HarnessRequest::State => Ok(vec![HarnessEvent::State {
1438 state: self.state.clone(),
1439 }]),
1440 HarnessRequest::Models => Ok(vec![HarnessEvent::Text {
1441 text: "The local harness has no model provider; configure the Pi adapter.".into(),
1442 }]),
1443 HarnessRequest::SetModel { .. } | HarnessRequest::SetThinking { .. } => {
1444 Ok(vec![HarnessEvent::Error {
1445 message: "model controls require the Pi harness adapter".into(),
1446 }])
1447 }
1448 HarnessRequest::NewSession => {
1449 self.state = "idle".into();
1450 Ok(vec![HarnessEvent::State {
1451 state: self.state.clone(),
1452 }])
1453 }
1454 HarnessRequest::Compact { .. }
1455 | HarnessRequest::CloneSession
1456 | HarnessRequest::Fork { .. }
1457 | HarnessRequest::SwitchSession { .. }
1458 | HarnessRequest::Entries { .. }
1459 | HarnessRequest::Messages
1460 | HarnessRequest::SessionStats
1461 | HarnessRequest::SetSessionName { .. } => Ok(vec![HarnessEvent::Error {
1462 message: "persistent session controls require the Pi runtime".into(),
1463 }]),
1464 }
1465 }
1466
1467 fn prompt(
1468 &mut self,
1469 workspace: &mut ProjectWorkspace,
1470 text: String,
1471 ) -> DevelopmentResult<Vec<HarnessEvent>> {
1472 if text.trim().is_empty() || text.len() > 8 * 1024 {
1473 return Ok(vec![HarnessEvent::Error {
1474 message: "prompt must be non-empty and at most 8192 bytes".into(),
1475 }]);
1476 }
1477 workspace.record_as(
1478 self.actor.clone(),
1479 DevelopmentEventKind::AgentPrompt,
1480 prompt_evidence(&text),
1481 )?;
1482 self.state = "working".into();
1483 let mut events = vec![HarnessEvent::State {
1484 state: self.state.clone(),
1485 }];
1486 let lower = text.to_ascii_lowercase();
1487 if text.split_whitespace().any(|token| token.starts_with('@')) {
1488 let packet =
1489 resolve_context_with_browser(workspace, &text, self.browser_context.as_ref())?;
1490 events.push(HarnessEvent::Text {
1491 text: serde_json::to_string(&packet)?,
1492 });
1493 } else if let Some(path) = text
1494 .strip_prefix("read ")
1495 .map(str::trim)
1496 .filter(|value| !value.is_empty())
1497 {
1498 let call = self.tool_call("glass.file.read", serde_json::json!({"path": path}));
1499 let id = call.id.clone();
1500 events.push(HarnessEvent::ToolCall(call.clone()));
1501 match self.gateway.execute(
1502 workspace,
1503 &call,
1504 &ToolAuthorization::read_only(self.actor.clone()),
1505 ) {
1506 Ok(result) => {
1507 events.push(HarnessEvent::ToolResult { id, result });
1508 }
1509 Err(error) => events.push(HarnessEvent::Error {
1510 message: error.to_string(),
1511 }),
1512 }
1513 } else if lower == "files" || lower == "list files" {
1514 let call = self.tool_call("glass.file.list", serde_json::json!({}));
1515 let id = call.id.clone();
1516 events.push(HarnessEvent::ToolCall(call.clone()));
1517 let result = self.gateway.execute(
1518 workspace,
1519 &call,
1520 &ToolAuthorization::read_only(self.actor.clone()),
1521 )?;
1522 events.push(HarnessEvent::ToolResult { id, result });
1523 } else if lower == "process list" || lower == "processes" {
1524 let call = self.tool_call("glass.process.list", serde_json::json!({}));
1525 let id = call.id.clone();
1526 events.push(HarnessEvent::ToolCall(call.clone()));
1527 let result = self.gateway.execute(
1528 workspace,
1529 &call,
1530 &ToolAuthorization::read_only(self.actor.clone()),
1531 )?;
1532 events.push(HarnessEvent::ToolResult { id, result });
1533 } else if lower == "diff" {
1534 let call = self.tool_call("glass.git.status", serde_json::json!({}));
1535 let id = call.id.clone();
1536 events.push(HarnessEvent::ToolCall(call.clone()));
1537 let result = self.gateway.execute(
1538 workspace,
1539 &call,
1540 &ToolAuthorization::read_only(self.actor.clone()),
1541 )?;
1542 events.push(HarnessEvent::ToolResult { id, result });
1543 } else {
1544 events.push(HarnessEvent::Text {
1545 text: "Glass local harness is ready. Try `read <path>`, `files`, `process list`, or `diff`.".into(),
1546 });
1547 }
1548 self.state = "idle".into();
1549 events.push(HarnessEvent::State {
1550 state: self.state.clone(),
1551 });
1552 Ok(events)
1553 }
1554
1555 fn tool_call(&mut self, name: &str, arguments: Value) -> ToolCall {
1556 let id = format!("tool-{}", self.next_tool_id);
1557 self.next_tool_id = self.next_tool_id.saturating_add(1);
1558 ToolCall {
1559 id,
1560 name: name.into(),
1561 arguments,
1562 }
1563 }
1564}
1565
1566pub struct PiHarness {
1571 child: Child,
1572 input: ChildStdin,
1573 output: Receiver<Value>,
1574 next_id: u64,
1575 extension_path: PathBuf,
1576 pending_ui_requests: BTreeSet<String>,
1577 unrestricted: bool,
1578}
1579
1580#[derive(Debug, Clone, Default)]
1581pub struct PiHarnessOptions {
1582 pub unrestricted: bool,
1583 pub persist_session: bool,
1584 pub session_id: Option<String>,
1585 pub fork: Option<String>,
1586 pub session_dir: Option<PathBuf>,
1587 pub name: Option<String>,
1588 pub model: Option<String>,
1589 pub thinking: Option<String>,
1590 pub broker_socket: Option<PathBuf>,
1591 pub broker_token: Option<String>,
1592 pub broker_workspace_id: Option<String>,
1593 pub additional_system_prompt: Option<String>,
1594}
1595
1596impl std::fmt::Debug for PiHarness {
1597 fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1598 formatter
1599 .debug_struct("PiHarness")
1600 .field("pid", &self.child.id())
1601 .field("next_id", &self.next_id)
1602 .finish()
1603 }
1604}
1605
1606impl PiHarness {
1607 pub fn spawn(root: &Path) -> DevelopmentResult<Self> {
1608 Self::spawn_with_unrestricted(root, false)
1609 }
1610
1611 pub fn spawn_with_unrestricted(root: &Path, unrestricted: bool) -> DevelopmentResult<Self> {
1612 Self::spawn_with_options(
1613 root,
1614 PiHarnessOptions {
1615 unrestricted,
1616 persist_session: env_enabled("GLASS_PI_PERSIST_SESSION"),
1617 ..PiHarnessOptions::default()
1618 },
1619 )
1620 }
1621
1622 pub fn spawn_with_options(root: &Path, options: PiHarnessOptions) -> DevelopmentResult<Self> {
1623 validate_pi_harness_options(&options)?;
1624 static NEXT_EXTENSION_ID: std::sync::atomic::AtomicU64 =
1625 std::sync::atomic::AtomicU64::new(1);
1626 let extension_id = NEXT_EXTENSION_ID.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
1627 let extension_path = std::env::temp_dir().join(format!(
1628 "glass-pi-tools-{}-{extension_id}.ts",
1629 std::process::id()
1630 ));
1631 std::fs::write(
1632 &extension_path,
1633 include_str!("../../assets/pi-glass-tools.ts"),
1634 )?;
1635 let broker = std::env::current_exe().map_err(DevelopmentError::Io)?;
1636 let trusted_resources = options.unrestricted || env_enabled("GLASS_PI_TRUSTED_RESOURCES");
1637 let mut system_prompt = if options.unrestricted {
1638 format!(
1639 "{}\n- UNRESTRICTED MODE is active. Glass will not ask for tool approval; execute requested local development work directly and report effects truthfully.",
1640 include_str!("../../assets/pi-glass-system.md")
1641 )
1642 } else {
1643 include_str!("../../assets/pi-glass-system.md").to_string()
1644 };
1645 if let Some(additional) = &options.additional_system_prompt {
1646 if additional.len() > 128 * 1024 || additional.contains('\0') {
1647 return Err(DevelopmentError::InvalidInput(
1648 "additional Pi system prompt exceeds 128 KiB or contains NUL".into(),
1649 ));
1650 }
1651 system_prompt.push_str(additional);
1652 }
1653 let mut command = Command::new("pi");
1654 command.args(["--mode", "rpc", "--no-approve", "--no-builtin-tools"]);
1655 if !env_enabled("GLASS_PI_ONLINE_CATALOG") {
1656 command.arg("--offline");
1657 }
1658 if !trusted_resources {
1659 command.args([
1660 "--no-context-files",
1661 "--no-extensions",
1662 "--no-skills",
1663 "--no-prompt-templates",
1664 "--no-themes",
1665 ]);
1666 }
1667 if !options.persist_session {
1668 command.arg("--no-session");
1669 }
1670 if let Some(session_id) = &options.session_id {
1671 command.args(["--session-id", session_id]);
1672 }
1673 if let Some(fork) = &options.fork {
1674 command.args(["--fork", fork]);
1675 }
1676 if let Some(session_dir) = &options.session_dir {
1677 std::fs::create_dir_all(session_dir)?;
1678 command.arg("--session-dir").arg(session_dir);
1679 }
1680 if let Some(name) = &options.name {
1681 command.args(["--name", name]);
1682 }
1683 if let Some(model) = &options.model {
1684 command.args(["--model", model]);
1685 }
1686 if let Some(thinking) = &options.thinking {
1687 command.args(["--thinking", thinking]);
1688 }
1689 if let Some(socket) = &options.broker_socket {
1690 command.env("GLASS_DEV_DAEMON_SOCKET", socket);
1691 }
1692 if let Some(token) = &options.broker_token {
1693 command.env("GLASS_DEV_DAEMON_TOKEN", token);
1694 }
1695 if let Some(workspace_id) = &options.broker_workspace_id {
1696 command.env("GLASS_DEV_DAEMON_WORKSPACE", workspace_id);
1697 }
1698 command
1699 .args(["--system-prompt", &system_prompt, "--extension"])
1700 .arg(&extension_path);
1701 if !trusted_resources {
1702 command.arg("--tools").arg(
1703 [
1704 "read",
1705 "write",
1706 "edit",
1707 "bash",
1708 "grep",
1709 "find",
1710 "ls",
1711 "glass_git_status",
1712 "glass_semantic_inspect",
1713 "glass_web_ir_inspect",
1714 "glass_web_ir_diff",
1715 "glass_web_ir_continuity",
1716 "glass_task_plan",
1717 "glass_runtime_inspect",
1718 "glass_capabilities",
1719 "glass_diagnostics_run",
1720 "glass_file_mkdir",
1721 "glass_file_rename",
1722 "glass_file_delete",
1723 "glass_test_run",
1724 "glass_process_list",
1725 "glass_process_start",
1726 "glass_process_stop",
1727 "glass_process_logs",
1728 "glass_process_restart",
1729 "glass_process_input",
1730 "glass_process_resize",
1731 "glass_process_health",
1732 "glass_process_ports",
1733 "glass_editor_open",
1734 "glass_editor_selection",
1735 "glass_editor_replace",
1736 "glass_editor_save",
1737 "glass_editor_diff",
1738 "glass_editor_buffers",
1739 "glass_browser_state",
1740 "glass_browser_start",
1741 "glass_browser_stop",
1742 "glass_browser_observe",
1743 "glass_browser_targets",
1744 "glass_browser_select_target",
1745 "glass_browser_navigate",
1746 "glass_browser_act",
1747 "glass_browser_screenshot",
1748 "glass_workflow_run",
1749 "glass_workflow_pause",
1750 "glass_workflow_resume",
1751 "glass_git_diff",
1752 "glass_git_stage",
1753 "glass_git_unstage",
1754 "glass_git_commit",
1755 "glass_git_branches",
1756 "glass_git_branch_create",
1757 "glass_git_branch_switch",
1758 "glass_git_blame",
1759 "glass_git_worktrees",
1760 "glass_git_worktree_create",
1761 "glass_git_worktree_remove",
1762 "glass_test_discover",
1763 "glass_test_run_suite",
1764 "glass_test_results",
1765 "glass_test_cancel",
1766 "glass_test_watch",
1767 "glass_eval_start",
1768 "glass_eval_execute",
1769 "glass_eval_list",
1770 "glass_eval_reset",
1771 "glass_eval_stop",
1772 "glass_lsp_diagnostics",
1773 "glass_lsp_hover",
1774 "glass_lsp_completion",
1775 "glass_lsp_definition",
1776 "glass_lsp_declaration",
1777 "glass_lsp_implementation",
1778 "glass_lsp_references",
1779 "glass_lsp_document_symbols",
1780 "glass_lsp_workspace_symbols",
1781 "glass_lsp_signature_help",
1782 "glass_lsp_code_actions",
1783 "glass_lsp_formatting",
1784 "glass_lsp_range_formatting",
1785 "glass_lsp_semantic_tokens",
1786 "glass_lsp_rename",
1787 "glass_debug_start",
1788 "glass_debug_launch",
1789 "glass_debug_attach",
1790 "glass_debug_breakpoint_set",
1791 "glass_debug_continue",
1792 "glass_debug_pause",
1793 "glass_debug_step",
1794 "glass_debug_stack",
1795 "glass_debug_scopes",
1796 "glass_debug_variables",
1797 "glass_debug_evaluate",
1798 "glass_debug_events",
1799 "glass_debug_stop",
1800 "glass_agent_list",
1801 "glass_agent_spawn",
1802 "glass_agent_prompt",
1803 "glass_agent_steer",
1804 "glass_agent_follow_up",
1805 "glass_agent_abort",
1806 "glass_agent_compact",
1807 "glass_agent_model",
1808 "glass_agent_thinking",
1809 "glass_agent_new_session",
1810 "glass_agent_clone_session",
1811 "glass_agent_fork",
1812 "glass_agent_switch_session",
1813 "glass_agent_messages",
1814 "glass_agent_entries",
1815 "glass_agent_stats",
1816 "glass_agent_name",
1817 "glass_graph_query",
1818 "glass_graph_path",
1819 "glass_replay_list",
1820 "glass_replay_diff",
1821 ]
1822 .join(","),
1823 );
1824 }
1825 let mut child = command
1826 .env("GLASS_PI_BROKER_BIN", broker)
1827 .env(
1828 "GLASS_PI_YOLO",
1829 if options.unrestricted { "1" } else { "0" },
1830 )
1831 .current_dir(root)
1832 .stdin(Stdio::piped())
1833 .stdout(Stdio::piped())
1834 .stderr(Stdio::null())
1835 .spawn()
1836 .map_err(|error| DevelopmentError::Process(format!("failed to start Pi: {error}")))?;
1837 let input = child
1838 .stdin
1839 .take()
1840 .ok_or_else(|| DevelopmentError::Process("Pi stdin is unavailable".into()))?;
1841 let output = child
1842 .stdout
1843 .take()
1844 .ok_or_else(|| DevelopmentError::Process("Pi stdout is unavailable".into()))?;
1845 let (sender, receiver) = mpsc::sync_channel(PI_EVENT_CHANNEL_CAPACITY);
1846 thread::Builder::new()
1847 .name("glass-pi-rpc".into())
1848 .spawn(move || {
1849 for line in BufReader::new(output).split(b'\n') {
1850 let Ok(mut line) = line else { break };
1851 if line.last() == Some(&b'\r') {
1852 line.pop();
1853 }
1854 if line.len() > MAX_PI_EVENT_BYTES {
1855 continue;
1856 }
1857 if let Ok(value) = serde_json::from_slice::<Value>(&line)
1858 && sender.send(value).is_err()
1859 {
1860 break;
1861 }
1862 }
1863 })
1864 .map_err(DevelopmentError::Io)?;
1865 Ok(Self {
1866 child,
1867 input,
1868 output: receiver,
1869 next_id: 1,
1870 extension_path,
1871 pending_ui_requests: BTreeSet::new(),
1872 unrestricted: options.unrestricted,
1873 })
1874 }
1875
1876 pub fn request(&mut self, request: HarnessRequest) -> DevelopmentResult<Vec<Value>> {
1877 let wait_for_agent = matches!(request, HarnessRequest::Prompt { .. });
1878 let id = self.start_request(request)?;
1879 let mut events = VecDeque::with_capacity(MAX_PI_BUFFERED_EVENTS);
1880 let mut response_received = false;
1881 let mut observed = 0_usize;
1882 loop {
1883 let value = self
1884 .recv_event_timeout(if response_received {
1885 Duration::from_secs(120)
1886 } else {
1887 PI_RESPONSE_TIMEOUT
1888 })?
1889 .ok_or_else(|| {
1890 DevelopmentError::Process(if response_received {
1891 "Pi agent event stream timed out".into()
1892 } else {
1893 "Pi RPC response timed out".into()
1894 })
1895 })?;
1896 observed = observed.saturating_add(1);
1897 let is_response = pi_response_matches(&value, &id);
1898 let failed =
1899 is_response && value.get("success").and_then(Value::as_bool) == Some(false);
1900 let settled = pi_agent_settled(&value);
1901 if let Some(request) = pi_ui_request(&value)? {
1902 if !self.unrestricted {
1903 self.respond_extension_ui(&request.id, false)?;
1907 }
1908 continue;
1909 }
1910 if pi_event_visible(&value) {
1911 if events.len() == MAX_PI_BUFFERED_EVENTS {
1912 events.pop_front();
1913 }
1914 events.push_back(value);
1915 }
1916 if failed {
1917 return Err(DevelopmentError::Process(format!(
1918 "Pi rejected RPC command {id}"
1919 )));
1920 }
1921 if is_response {
1922 response_received = true;
1923 if !wait_for_agent {
1924 return Ok(events.into());
1925 }
1926 }
1927 if response_received && settled {
1928 return Ok(events.into());
1929 }
1930 if observed >= 4096 {
1931 return Err(DevelopmentError::Process(
1932 "Pi emitted too many events before settling".into(),
1933 ));
1934 }
1935 }
1936 }
1937
1938 pub fn start_request(&mut self, request: HarnessRequest) -> DevelopmentResult<String> {
1939 let (command, private_text) = match request {
1940 HarnessRequest::Hello | HarnessRequest::State => {
1941 (serde_json::json!({"type": "get_state"}), None)
1942 }
1943 HarnessRequest::Prompt { text } => (
1944 serde_json::json!({"type": "prompt", "message": text}),
1945 Some(()),
1946 ),
1947 HarnessRequest::Steer { text } => (
1948 serde_json::json!({"type": "steer", "message": text}),
1949 Some(()),
1950 ),
1951 HarnessRequest::FollowUp { text } => (
1952 serde_json::json!({"type": "follow_up", "message": text}),
1953 Some(()),
1954 ),
1955 HarnessRequest::Abort => (serde_json::json!({"type": "abort"}), None),
1956 HarnessRequest::Models => (serde_json::json!({"type": "get_available_models"}), None),
1957 HarnessRequest::SetModel { provider, model_id } => (
1958 serde_json::json!({"type": "set_model", "provider": provider, "modelId": model_id}),
1959 None,
1960 ),
1961 HarnessRequest::SetThinking { level } => (
1962 serde_json::json!({"type": "set_thinking_level", "level": level}),
1963 None,
1964 ),
1965 HarnessRequest::NewSession => (serde_json::json!({"type": "new_session"}), None),
1966 HarnessRequest::Compact { instructions } => (
1967 serde_json::json!({"type": "compact", "customInstructions": instructions}),
1968 None,
1969 ),
1970 HarnessRequest::CloneSession => (serde_json::json!({"type": "clone"}), None),
1971 HarnessRequest::Fork { entry_id } => (
1972 serde_json::json!({"type": "fork", "entryId": entry_id}),
1973 None,
1974 ),
1975 HarnessRequest::SwitchSession { path } => (
1976 serde_json::json!({"type": "switch_session", "sessionPath": path}),
1977 None,
1978 ),
1979 HarnessRequest::Entries { since } => (
1980 serde_json::json!({"type": "get_entries", "since": since}),
1981 None,
1982 ),
1983 HarnessRequest::Messages => (serde_json::json!({"type": "get_messages"}), None),
1984 HarnessRequest::SessionStats => {
1985 (serde_json::json!({"type": "get_session_stats"}), None)
1986 }
1987 HarnessRequest::SetSessionName { name } => (
1988 serde_json::json!({"type": "set_session_name", "name": name}),
1989 None,
1990 ),
1991 };
1992 let _private_text = private_text;
1993 self.send(command)
1994 }
1995
1996 fn send(&mut self, mut command: Value) -> DevelopmentResult<String> {
1997 let id = format!("glass-{}", self.next_id);
1998 self.next_id = self.next_id.saturating_add(1);
1999 command["id"] = Value::String(id.clone());
2000 let encoded = serde_json::to_vec(&command)?;
2001 if encoded.len() > 1024 * 1024 {
2002 return Err(DevelopmentError::InvalidInput(
2003 "Pi RPC command exceeds the 1 MiB limit".into(),
2004 ));
2005 }
2006 self.input.write_all(&encoded)?;
2007 self.input.write_all(b"\n")?;
2008 self.input.flush()?;
2009 Ok(id)
2010 }
2011
2012 pub fn respond_extension_ui(&mut self, id: &str, confirmed: bool) -> DevelopmentResult<()> {
2013 if !self.pending_ui_requests.remove(id) {
2014 return Err(DevelopmentError::Conflict(format!(
2015 "stale or unknown Pi UI request: {id}"
2016 )));
2017 }
2018 let encoded = serde_json::to_vec(&serde_json::json!({
2019 "type": "extension_ui_response",
2020 "id": id,
2021 "confirmed": confirmed,
2022 }))?;
2023 self.input.write_all(&encoded)?;
2024 self.input.write_all(b"\n")?;
2025 self.input.flush()?;
2026 Ok(())
2027 }
2028
2029 pub fn recv_event_timeout(&mut self, timeout: Duration) -> DevelopmentResult<Option<Value>> {
2030 match self.output.recv_timeout(timeout) {
2031 Ok(value) => {
2032 if let Some(request) = pi_ui_request(&value)?
2033 && !self.pending_ui_requests.insert(request.id.clone())
2034 {
2035 return Err(DevelopmentError::Conflict(format!(
2036 "duplicate Pi UI request: {}",
2037 request.id
2038 )));
2039 }
2040 if self.pending_ui_requests.len() > 8 {
2041 return Err(DevelopmentError::Conflict(
2042 "too many pending Pi UI requests".into(),
2043 ));
2044 }
2045 if self.unrestricted
2046 && let Some(request) = pi_ui_request(&value)?
2047 {
2048 self.respond_extension_ui(&request.id, true)?;
2049 }
2050 Ok(Some(value))
2051 }
2052 Err(RecvTimeoutError::Timeout) => Ok(None),
2053 Err(RecvTimeoutError::Disconnected) => Err(DevelopmentError::Process(
2054 "Pi RPC event stream closed".into(),
2055 )),
2056 }
2057 }
2058}
2059
2060fn validate_pi_harness_options(options: &PiHarnessOptions) -> DevelopmentResult<()> {
2061 let broker_fields = [
2062 options.broker_socket.is_some(),
2063 options.broker_token.is_some(),
2064 options.broker_workspace_id.is_some(),
2065 ];
2066 if broker_fields.iter().any(|present| *present) && !broker_fields.iter().all(|present| *present)
2067 {
2068 return Err(DevelopmentError::InvalidInput(
2069 "Pi resident broker socket, token, and workspace must be configured together".into(),
2070 ));
2071 }
2072 if let Some(socket) = &options.broker_socket
2073 && (!socket.is_absolute() || socket == Path::new("/"))
2074 {
2075 return Err(DevelopmentError::InvalidInput(
2076 "Pi resident broker socket must be an explicit absolute path".into(),
2077 ));
2078 }
2079 for (description, value, limit) in [
2080 ("broker token", options.broker_token.as_deref(), 256),
2081 (
2082 "broker workspace",
2083 options.broker_workspace_id.as_deref(),
2084 128,
2085 ),
2086 ] {
2087 if let Some(value) = value
2088 && (value.is_empty() || value.len() > limit || value.chars().any(char::is_control))
2089 {
2090 return Err(DevelopmentError::InvalidInput(format!(
2091 "Pi {description} must contain 1..={limit} non-control bytes"
2092 )));
2093 }
2094 }
2095 if options.session_id.is_some() && options.fork.is_some() {
2096 return Err(DevelopmentError::InvalidInput(
2097 "Pi session ID and fork source are mutually exclusive".into(),
2098 ));
2099 }
2100 if (options.session_id.is_some()
2101 || options.fork.is_some()
2102 || options.session_dir.is_some()
2103 || options.name.is_some())
2104 && !options.persist_session
2105 {
2106 return Err(DevelopmentError::InvalidInput(
2107 "Pi session options require persistent session storage".into(),
2108 ));
2109 }
2110 for (description, value, limit) in [
2111 ("session ID", options.session_id.as_deref(), 256),
2112 ("fork source", options.fork.as_deref(), 4096),
2113 ("session name", options.name.as_deref(), 256),
2114 ("model", options.model.as_deref(), 512),
2115 ] {
2116 if let Some(value) = value
2117 && (value.is_empty()
2118 || value.len() > limit
2119 || value.chars().any(|character| character.is_control()))
2120 {
2121 return Err(DevelopmentError::InvalidInput(format!(
2122 "Pi {description} must contain 1..={limit} non-control bytes"
2123 )));
2124 }
2125 }
2126 if let Some(thinking) = options.thinking.as_deref()
2127 && !matches!(
2128 thinking,
2129 "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max"
2130 )
2131 {
2132 return Err(DevelopmentError::InvalidInput(
2133 "Pi thinking level must be off, minimal, low, medium, high, xhigh, or max".into(),
2134 ));
2135 }
2136 if let Some(directory) = &options.session_dir
2137 && (!directory.is_absolute() || directory == Path::new("/"))
2138 {
2139 return Err(DevelopmentError::InvalidInput(
2140 "Pi session directory must be an explicit absolute path".into(),
2141 ));
2142 }
2143 Ok(())
2144}
2145
2146fn env_enabled(name: &str) -> bool {
2147 std::env::var(name).is_ok_and(|value| value == "1" || value.eq_ignore_ascii_case("true"))
2148}
2149
2150#[derive(Debug, Clone, PartialEq, Eq)]
2151pub(crate) struct PiUiRequest {
2152 pub id: String,
2153 pub title: String,
2154 pub message: String,
2155}
2156
2157pub(crate) fn pi_ui_request(value: &Value) -> DevelopmentResult<Option<PiUiRequest>> {
2158 if value.get("type").and_then(Value::as_str) != Some("extension_ui_request") {
2159 return Ok(None);
2160 }
2161 let id = value
2162 .get("id")
2163 .and_then(Value::as_str)
2164 .filter(|id| !id.is_empty() && id.len() <= 128 && !id.chars().any(char::is_control))
2165 .ok_or_else(|| DevelopmentError::InvalidInput("invalid Pi UI request id".into()))?;
2166 let method = value.get("method").and_then(Value::as_str).unwrap_or("");
2167 if method != "confirm" {
2168 return Err(DevelopmentError::InvalidInput(format!(
2169 "unsupported Pi UI request method: {method}"
2170 )));
2171 }
2172 let bounded_field = |name: &str, limit: usize| -> DevelopmentResult<String> {
2173 let field = value.get(name).and_then(Value::as_str).unwrap_or("");
2174 if field.len() > limit || field.chars().any(|character| character == '\0') {
2175 return Err(DevelopmentError::InvalidInput(format!(
2176 "invalid Pi UI request {name}"
2177 )));
2178 }
2179 Ok(field.to_string())
2180 };
2181 Ok(Some(PiUiRequest {
2182 id: id.to_string(),
2183 title: bounded_field("title", 256)?,
2184 message: bounded_field("message", 2048)?,
2185 }))
2186}
2187
2188pub(crate) fn pi_response_matches(value: &Value, id: &str) -> bool {
2189 value.get("type").and_then(Value::as_str) == Some("response")
2190 && value.get("id").and_then(Value::as_str) == Some(id)
2191}
2192
2193pub(crate) fn pi_agent_settled(value: &Value) -> bool {
2194 value.get("type").and_then(Value::as_str) == Some("agent_settled")
2195}
2196
2197pub(crate) fn pi_event_visible(value: &Value) -> bool {
2198 if value.get("type").and_then(Value::as_str) == Some("message_end") {
2199 return value
2200 .get("message")
2201 .and_then(|message| message.get("role"))
2202 .and_then(Value::as_str)
2203 == Some("assistant");
2204 }
2205 matches!(
2206 value.get("type").and_then(Value::as_str),
2207 Some(
2208 "response"
2209 | "tool_execution_start"
2210 | "tool_execution_end"
2211 | "agent_settled"
2212 | "extension_error"
2213 | "extension_ui_request"
2214 )
2215 )
2216}
2217
2218pub fn pi_event_display(value: &Value) -> Option<String> {
2219 match value.get("type").and_then(Value::as_str)? {
2220 "message_end" => {
2221 let message = value.get("message")?;
2222 if message.get("role").and_then(Value::as_str) != Some("assistant") {
2223 return None;
2224 }
2225 let content = message.get("content")?;
2226 if let Some(text) = content.as_str() {
2227 return (!text.is_empty()).then(|| text.to_string());
2228 }
2229 let text = content
2230 .as_array()?
2231 .iter()
2232 .filter(|part| part.get("type").and_then(Value::as_str) == Some("text"))
2233 .filter_map(|part| part.get("text").and_then(Value::as_str))
2234 .collect::<Vec<_>>()
2235 .join("\n");
2236 (!text.is_empty()).then_some(text)
2237 }
2238 "tool_execution_start" => Some(format!(
2239 "Pi tool running: {}",
2240 value
2241 .get("toolName")
2242 .and_then(Value::as_str)
2243 .unwrap_or("unknown")
2244 )),
2245 "tool_execution_end" => Some(format!(
2246 "Pi tool {}: {}",
2247 value
2248 .get("toolName")
2249 .and_then(Value::as_str)
2250 .unwrap_or("unknown"),
2251 if value.get("isError").and_then(Value::as_bool) == Some(true) {
2252 "failed"
2253 } else {
2254 "completed"
2255 }
2256 )),
2257 "extension_error" => Some(format!(
2258 "Pi extension error: {}",
2259 value
2260 .get("error")
2261 .and_then(Value::as_str)
2262 .unwrap_or("unknown error")
2263 )),
2264 "response" => serde_json::to_string_pretty(value).ok(),
2265 "agent_settled" | "extension_ui_request" => None,
2266 _ => None,
2267 }
2268}
2269
2270impl Drop for PiHarness {
2271 fn drop(&mut self) {
2272 let _ = self.child.kill();
2273 let _ = self.child.wait();
2274 let _ = std::fs::remove_file(&self.extension_path);
2275 }
2276}
2277
2278fn prompt_evidence(text: &str) -> Value {
2279 let digest = Sha256::digest(text.as_bytes());
2280 serde_json::json!({
2281 "bytes": text.len(),
2282 "sha256": digest.iter().map(|byte| format!("{byte:02x}")).collect::<String>()
2283 })
2284}
2285
2286#[cfg(test)]
2287mod tests {
2288 use super::*;
2289 use std::fs;
2290
2291 #[test]
2292 fn pi_session_options_require_safe_persistent_configuration() {
2293 let directory = std::env::temp_dir().join("glass-pi-sessions");
2294 assert!(
2295 validate_pi_harness_options(&PiHarnessOptions {
2296 persist_session: true,
2297 session_id: Some("session-1".into()),
2298 session_dir: Some(directory),
2299 thinking: Some("high".into()),
2300 ..PiHarnessOptions::default()
2301 })
2302 .is_ok()
2303 );
2304 assert!(
2305 validate_pi_harness_options(&PiHarnessOptions {
2306 session_id: Some("session-1".into()),
2307 ..PiHarnessOptions::default()
2308 })
2309 .is_err()
2310 );
2311 assert!(
2312 validate_pi_harness_options(&PiHarnessOptions {
2313 persist_session: true,
2314 thinking: Some("unbounded".into()),
2315 ..PiHarnessOptions::default()
2316 })
2317 .is_err()
2318 );
2319 }
2320
2321 #[test]
2322 fn local_harness_proves_prompt_tool_result_and_steer_events() {
2323 let root = std::env::temp_dir().join(format!("glass-agent-{}", std::process::id()));
2324 let _ = fs::remove_dir_all(&root);
2325 fs::create_dir_all(&root).unwrap();
2326 fs::write(root.join("note.txt"), "hello agent").unwrap();
2327 let mut workspace = ProjectWorkspace::open(&root).unwrap();
2328 let mut harness = LocalHarness::default();
2329 assert!(matches!(
2330 harness
2331 .handle(&mut workspace, HarnessRequest::Hello)
2332 .unwrap()[0],
2333 HarnessEvent::Hello { .. }
2334 ));
2335 let events = harness
2336 .handle(
2337 &mut workspace,
2338 HarnessRequest::Prompt {
2339 text: "read note.txt".into(),
2340 },
2341 )
2342 .unwrap();
2343 assert!(
2344 events
2345 .iter()
2346 .any(|event| matches!(event, HarnessEvent::ToolCall(_)))
2347 );
2348 assert!(
2349 events
2350 .iter()
2351 .any(|event| matches!(event, HarnessEvent::ToolResult { .. }))
2352 );
2353 assert!(matches!(
2354 harness
2355 .handle(
2356 &mut workspace,
2357 HarnessRequest::Steer {
2358 text: "stop".into()
2359 }
2360 )
2361 .unwrap()[0],
2362 HarnessEvent::State { .. }
2363 ));
2364 assert!(workspace.timeline().events().all(|event| {
2365 !event.payload.to_string().contains("read note.txt")
2366 && !event.payload.to_string().contains("stop")
2367 }));
2368 let _ = fs::remove_dir_all(root);
2369 }
2370
2371 #[test]
2372 fn pi_adapter_negotiates_real_rpc_state_when_pi_is_available() {
2373 if Command::new("pi").arg("--version").output().is_err() {
2374 return;
2375 }
2376 let mut harness = PiHarness::spawn(Path::new(".")).unwrap();
2377 let events = harness.request(HarnessRequest::Hello).unwrap();
2378 assert!(
2379 !events.iter().any(|event| {
2380 event.get("type").and_then(Value::as_str) == Some("extension_error")
2381 })
2382 );
2383 assert!(events.iter().any(|event| {
2384 event.get("type").and_then(Value::as_str) == Some("response")
2385 && event.get("command").and_then(Value::as_str) == Some("get_state")
2386 && event.get("success").and_then(Value::as_bool) == Some(true)
2387 }));
2388 }
2389
2390 #[test]
2391 fn pi_contract_is_glass_specific_approved_and_event_bounded() {
2392 let prompt = include_str!("../../assets/pi-glass-system.md");
2393 let tools = include_str!("../../assets/pi-glass-tools.ts");
2394 assert!(prompt.contains("embedded inside Glass Dev"));
2395 assert!(prompt.contains("Structured browser observation is the default"));
2396 assert!(prompt.contains("per-call approval"));
2397 assert!(prompt.contains("queued, running, indeterminate, stale, or background"));
2398 assert!(prompt.contains("300 seconds"));
2399 for tool in [
2400 "glass_git_status",
2401 "glass_semantic_inspect",
2402 "glass_web_ir_inspect",
2403 "glass_web_ir_diff",
2404 "glass_web_ir_continuity",
2405 "glass_task_plan",
2406 "glass_runtime_inspect",
2407 "glass_capabilities",
2408 "glass_diagnostics_run",
2409 "glass_file_mkdir",
2410 "glass_file_rename",
2411 "glass_file_delete",
2412 "glass_test_run",
2413 "glass_process_start",
2414 "glass_process_stop",
2415 "\"read\"",
2416 "\"write\"",
2417 "\"edit\"",
2418 "\"bash\"",
2419 "\"grep\"",
2420 "\"find\"",
2421 "\"ls\"",
2422 ] {
2423 assert!(tools.contains(tool), "missing Pi tool {tool}");
2424 }
2425 assert!(tools.contains("ctx.ui.confirm"));
2426 assert!(tools.contains("GLASS_PI_YOLO"));
2427 assert!(tools.contains("mutating && !unrestricted"));
2428 assert!(tools.contains("--allow-mutation"));
2429 assert!(tools.contains("exact serialized call once"));
2430 assert!(tools.contains("register(\"glass_process_start\", \"glass.process.start\""));
2431 assert!(tools.contains("register(\"glass_process_stop\", \"glass.process.stop\""));
2432
2433 let response = serde_json::json!({
2434 "type": "response",
2435 "id": "glass-9",
2436 "command": "prompt",
2437 "success": true
2438 });
2439 assert!(pi_response_matches(&response, "glass-9"));
2440 assert!(pi_event_visible(&response));
2441 assert!(!pi_agent_settled(&response));
2442 assert!(!pi_event_visible(
2443 &serde_json::json!({"type":"message_update"})
2444 ));
2445 assert!(!pi_event_visible(&serde_json::json!({
2446 "type":"message_end",
2447 "message":{"role":"user","content":"private prompt"}
2448 })));
2449 assert!(!pi_agent_settled(&serde_json::json!({"type":"agent_end"})));
2450 assert!(pi_agent_settled(
2451 &serde_json::json!({"type":"agent_settled"})
2452 ));
2453 assert_eq!(
2454 pi_event_display(&serde_json::json!({
2455 "type":"message_end",
2456 "message":{"role":"assistant","content":[{"type":"text","text":"done"}]}
2457 })),
2458 Some("done".into())
2459 );
2460 }
2461
2462 #[test]
2463 fn pi_ui_requests_accept_only_bounded_confirm_dialogs() {
2464 let request = serde_json::json!({
2465 "type":"extension_ui_request",
2466 "id":"approval-7",
2467 "method":"confirm",
2468 "title":"Approve glass.file.patch?",
2469 "message":"File: src/main.rs"
2470 });
2471 assert_eq!(
2472 pi_ui_request(&request).unwrap(),
2473 Some(PiUiRequest {
2474 id: "approval-7".into(),
2475 title: "Approve glass.file.patch?".into(),
2476 message: "File: src/main.rs".into(),
2477 })
2478 );
2479 assert!(
2480 pi_ui_request(&serde_json::json!({
2481 "type":"extension_ui_request", "id":"x", "method":"input"
2482 }))
2483 .is_err()
2484 );
2485 assert!(
2486 pi_ui_request(&serde_json::json!({
2487 "type":"extension_ui_request", "id":"bad\nid", "method":"confirm"
2488 }))
2489 .is_err()
2490 );
2491 }
2492
2493 #[test]
2494 fn tool_registry_executes_attributed_file_patch_and_fails_closed_for_unattached_browser() {
2495 let root = std::env::temp_dir().join(format!("glass-tools-{}", std::process::id()));
2496 let _ = fs::remove_dir_all(&root);
2497 fs::create_dir_all(&root).unwrap();
2498 fs::write(root.join("note.txt"), "before\n").unwrap();
2499 let mut workspace = ProjectWorkspace::open(&root).unwrap();
2500 let gateway = AgentToolGateway::default();
2501 let result = gateway
2502 .execute(
2503 &mut workspace,
2504 &ToolCall {
2505 id: "tool-1".into(),
2506 name: "glass.file.patch".into(),
2507 arguments: serde_json::json!({"path":"note.txt","search":"before","replace":"after"}),
2508 },
2509 &ToolAuthorization {
2510 actor: Actor::embedded(),
2511 allow_mutation: true,
2512 confirmed: true,
2513 },
2514 )
2515 .unwrap();
2516 assert_eq!(result["replacements"], 1);
2517 assert_eq!(
2518 fs::read_to_string(root.join("note.txt")).unwrap(),
2519 "after\n"
2520 );
2521 assert!(
2522 gateway
2523 .execute(
2524 &mut workspace,
2525 &ToolCall {
2526 id: "tool-2".into(),
2527 name: "glass.browser.observe".into(),
2528 arguments: serde_json::json!({}),
2529 },
2530 &ToolAuthorization::read_only(Actor::embedded()),
2531 )
2532 .is_err()
2533 );
2534 let _ = fs::remove_dir_all(root);
2535 }
2536
2537 #[test]
2538 fn tool_gateway_rejects_unconfirmed_mutation_and_unknown_arguments_without_audit_leaks() {
2539 let root = std::env::temp_dir().join(format!("glass-tool-policy-{}", std::process::id()));
2540 let _ = fs::remove_dir_all(&root);
2541 fs::create_dir_all(&root).unwrap();
2542 fs::write(root.join("note.txt"), "private-before\n").unwrap();
2543 let mut workspace = ProjectWorkspace::open(&root).unwrap();
2544 let gateway = AgentToolGateway::default();
2545 let mutating = ToolCall {
2546 id: "denied".into(),
2547 name: "glass.file.patch".into(),
2548 arguments: serde_json::json!({
2549 "path":"note.txt",
2550 "search":"private-before",
2551 "replace":"private-after"
2552 }),
2553 };
2554 assert!(
2555 gateway
2556 .execute(
2557 &mut workspace,
2558 &mutating,
2559 &ToolAuthorization::read_only(Actor::embedded()),
2560 )
2561 .is_err()
2562 );
2563 assert_eq!(
2564 fs::read_to_string(root.join("note.txt")).unwrap(),
2565 "private-before\n"
2566 );
2567
2568 let invalid = ToolCall {
2569 id: "invalid".into(),
2570 name: "glass.file.list".into(),
2571 arguments: serde_json::json!({"unexpected":"private-value"}),
2572 };
2573 assert!(
2574 gateway
2575 .execute(
2576 &mut workspace,
2577 &invalid,
2578 &ToolAuthorization::read_only(Actor::embedded()),
2579 )
2580 .is_err()
2581 );
2582 let audit =
2583 serde_json::to_string(&workspace.timeline().events().collect::<Vec<_>>()).unwrap();
2584 assert!(!audit.contains("private-before"));
2585 assert!(!audit.contains("private-after"));
2586 assert!(!audit.contains("private-value"));
2587 let _ = fs::remove_dir_all(root);
2588 }
2589
2590 #[test]
2591 fn coding_gateway_writes_and_applies_atomic_multi_edits() {
2592 let root = std::env::temp_dir().join(format!("glass-coding-tools-{}", std::process::id()));
2593 let _ = fs::remove_dir_all(&root);
2594 fs::create_dir_all(&root).unwrap();
2595 let mut workspace = ProjectWorkspace::open(&root).unwrap();
2596 let gateway = AgentToolGateway::default();
2597 let authority = ToolAuthorization {
2598 actor: Actor::external("pi"),
2599 allow_mutation: true,
2600 confirmed: true,
2601 };
2602 gateway
2603 .execute(
2604 &mut workspace,
2605 &ToolCall {
2606 id: "write-1".into(),
2607 name: "glass.file.write".into(),
2608 arguments: serde_json::json!({
2609 "path":"src/example.rs",
2610 "content":"fn alpha() {}\nfn beta() {}\n"
2611 }),
2612 },
2613 &authority,
2614 )
2615 .unwrap();
2616 let result = gateway
2617 .execute(
2618 &mut workspace,
2619 &ToolCall {
2620 id: "edit-1".into(),
2621 name: "glass.file.edit".into(),
2622 arguments: serde_json::json!({
2623 "path":"src/example.rs",
2624 "edits":[
2625 {"oldText":"alpha", "newText":"first"},
2626 {"oldText":"beta", "newText":"second"}
2627 ]
2628 }),
2629 },
2630 &authority,
2631 )
2632 .unwrap();
2633 assert_eq!(result["replacements"], 2);
2634 assert_eq!(
2635 fs::read_to_string(root.join("src/example.rs")).unwrap(),
2636 "fn first() {}\nfn second() {}\n"
2637 );
2638 let read = gateway
2639 .execute(
2640 &mut workspace,
2641 &ToolCall {
2642 id: "read-page".into(),
2643 name: "glass.file.read".into(),
2644 arguments: serde_json::json!({"path":"src/example.rs","offset":2,"limit":1}),
2645 },
2646 &ToolAuthorization::read_only(Actor::external("pi")),
2647 )
2648 .unwrap();
2649 assert_eq!(read["content"], "fn second() {}\n");
2650 assert_eq!(read["offset"], 2);
2651 assert!(
2652 read["sha256"]
2653 .as_str()
2654 .is_some_and(|value| value.len() == 64)
2655 );
2656
2657 {
2658 let command = "printf command-private-value";
2659 let command_result = gateway
2660 .execute(
2661 &mut workspace,
2662 &ToolCall {
2663 id: "command-1".into(),
2664 name: "glass.command.run".into(),
2665 arguments: serde_json::json!({
2666 "name":"pi-command-test", "command":command, "timeoutSeconds":5
2667 }),
2668 },
2669 &authority,
2670 )
2671 .unwrap();
2672 assert!(
2673 command_result["output"]
2674 .as_str()
2675 .is_some_and(|value| value.contains("command-private-value"))
2676 );
2677 assert!(
2678 workspace
2679 .timeline()
2680 .events()
2681 .all(|event| !event.payload.to_string().contains(command))
2682 );
2683 assert!(workspace.timeline().events().all(|event| !matches!(
2684 event.kind,
2685 DevelopmentEventKind::TestStarted | DevelopmentEventKind::TestCompleted
2686 )));
2687 }
2688 let _ = fs::remove_dir_all(root);
2689 }
2690
2691 #[test]
2692 fn coding_gateway_lists_finds_and_greps_with_bounded_standard_semantics() {
2693 let root = std::env::temp_dir().join(format!("glass-coding-search-{}", std::process::id()));
2694 let _ = fs::remove_dir_all(&root);
2695 fs::create_dir_all(root.join("src/nested")).unwrap();
2696 fs::write(root.join("src/lib.rs"), "alpha\nNeedle target\nomega\n").unwrap();
2697 fs::write(root.join("src/nested/mod.rs"), "needle second\n").unwrap();
2698 fs::write(root.join("README.md"), "Needle outside\n").unwrap();
2699 let mut workspace = ProjectWorkspace::open(&root).unwrap();
2700 let gateway = AgentToolGateway::default();
2701 let authority = ToolAuthorization::read_only(Actor::external("pi"));
2702
2703 let listed = gateway
2704 .execute(
2705 &mut workspace,
2706 &ToolCall {
2707 id: "list-src".into(),
2708 name: "glass.file.list".into(),
2709 arguments: serde_json::json!({"path":"src","limit":2}),
2710 },
2711 &authority,
2712 )
2713 .unwrap();
2714 assert_eq!(listed["entries"].as_array().unwrap().len(), 2);
2715 assert_eq!(listed["truncated"], true);
2716 assert!(
2717 listed["entries"]
2718 .as_array()
2719 .unwrap()
2720 .iter()
2721 .all(|entry| entry["path"].as_str().unwrap().starts_with("src"))
2722 );
2723
2724 let found = gateway
2725 .execute(
2726 &mut workspace,
2727 &ToolCall {
2728 id: "find-rs".into(),
2729 name: "glass.file.find".into(),
2730 arguments: serde_json::json!({"pattern":"src/*.rs","limit":20}),
2731 },
2732 &authority,
2733 )
2734 .unwrap();
2735 assert_eq!(found["paths"].as_array().unwrap().len(), 2);
2736
2737 let grep = gateway
2738 .execute(
2739 &mut workspace,
2740 &ToolCall {
2741 id: "grep-needle".into(),
2742 name: "glass.file.grep".into(),
2743 arguments: serde_json::json!({
2744 "pattern":"needle", "path":"src", "glob":"*.rs",
2745 "ignoreCase":true, "context":1, "limit":10
2746 }),
2747 },
2748 &authority,
2749 )
2750 .unwrap();
2751 assert_eq!(grep["matches"].as_array().unwrap().len(), 2);
2752 assert_eq!(grep["literal"], true);
2753 assert_eq!(grep["matches"][0]["contextBefore"][0], "alpha");
2754 let _ = fs::remove_dir_all(root);
2755 }
2756
2757 #[test]
2758 fn tool_gateway_bounds_envelopes_and_reuses_its_descriptor_catalog() {
2759 let root = std::env::temp_dir().join(format!("glass-tool-envelope-{}", std::process::id()));
2760 let _ = fs::remove_dir_all(&root);
2761 fs::create_dir_all(&root).unwrap();
2762 let mut workspace = ProjectWorkspace::open(&root).unwrap();
2763 let gateway = AgentToolGateway::default();
2764 let descriptor_storage = gateway.descriptors.as_ptr();
2765
2766 for (id, name) in [("", "glass.file.list"), ("valid", "bad name")] {
2767 let error = gateway
2768 .execute(
2769 &mut workspace,
2770 &ToolCall {
2771 id: id.into(),
2772 name: name.into(),
2773 arguments: serde_json::json!({}),
2774 },
2775 &ToolAuthorization::read_only(Actor::embedded()),
2776 )
2777 .unwrap_err();
2778 assert!(matches!(error, DevelopmentError::InvalidInput(_)));
2779 }
2780 let oversized_id = "x".repeat(MAX_TOOL_CALL_ID_BYTES + 1);
2781 assert!(
2782 gateway
2783 .execute(
2784 &mut workspace,
2785 &ToolCall {
2786 id: oversized_id,
2787 name: "glass.file.list".into(),
2788 arguments: serde_json::json!({}),
2789 },
2790 &ToolAuthorization::read_only(Actor::embedded()),
2791 )
2792 .is_err()
2793 );
2794 assert_eq!(descriptor_storage, gateway.descriptors.as_ptr());
2795 let _ = fs::remove_dir_all(root);
2796 }
2797
2798 #[test]
2799 fn subprocess_broker_reports_resident_process_tools_as_unavailable() {
2800 let gateway = AgentToolGateway::subprocess_broker();
2801 for name in [
2802 "glass.process.start",
2803 "glass.process.stop",
2804 "glass.process.logs",
2805 "glass.process.list",
2806 ] {
2807 let descriptor = gateway
2808 .descriptors()
2809 .into_iter()
2810 .find(|descriptor| descriptor.name == name)
2811 .unwrap();
2812 assert!(!descriptor.available);
2813 assert!(
2814 descriptor
2815 .unavailable_reason
2816 .as_deref()
2817 .is_some_and(|reason| reason.contains("resident Glass Dev"))
2818 );
2819 }
2820 let root = std::env::temp_dir().join(format!("glass-capabilities-{}", std::process::id()));
2821 let _ = fs::remove_dir_all(&root);
2822 fs::create_dir_all(&root).unwrap();
2823 let mut workspace = ProjectWorkspace::open(&root).unwrap();
2824 let result = gateway
2825 .execute(
2826 &mut workspace,
2827 &ToolCall {
2828 id: "capabilities".into(),
2829 name: "glass.capabilities.inspect".into(),
2830 arguments: serde_json::json!({}),
2831 },
2832 &ToolAuthorization::read_only(Actor::external("pi")),
2833 )
2834 .unwrap();
2835 let processes = result
2836 .as_array()
2837 .unwrap()
2838 .iter()
2839 .filter(|descriptor| {
2840 descriptor["name"]
2841 .as_str()
2842 .is_some_and(|name| name.starts_with("glass.process."))
2843 })
2844 .collect::<Vec<_>>();
2845 assert_eq!(processes.len(), 5);
2846 assert!(
2847 processes
2848 .iter()
2849 .all(|descriptor| descriptor["available"] == false)
2850 );
2851 let _ = fs::remove_dir_all(root);
2852 }
2853
2854 #[test]
2855 fn attached_browser_enables_structured_observation_without_mutation_authority() {
2856 let root = std::env::temp_dir().join(format!("glass-tool-browser-{}", std::process::id()));
2857 let _ = fs::remove_dir_all(&root);
2858 fs::create_dir_all(&root).unwrap();
2859 let mut workspace = ProjectWorkspace::open(&root).unwrap();
2860 let mut gateway = AgentToolGateway::default();
2861 gateway.set_browser_context(Some(BrowserAgentContext {
2862 connected: true,
2863 target_id: Some("page-1".into()),
2864 origin: Some("https://example.test".into()),
2865 url: "https://example.test/".into(),
2866 title: "Example".into(),
2867 browser_revision: 42,
2868 semantic_summary: "button Continue".into(),
2869 semantic_entity_count: 1,
2870 selected_entity: Some(serde_json::json!({"reference":"e1","name":"Continue"})),
2871 workflow_state: "idle".into(),
2872 input_owner: "Glass".into(),
2873 freshness: "current".into(),
2874 memory_scope: "profile/default".into(),
2875 }));
2876 let descriptor = gateway
2877 .descriptors()
2878 .into_iter()
2879 .find(|item| item.name == "glass.browser.observe")
2880 .unwrap();
2881 assert!(descriptor.available);
2882 let result = gateway
2883 .execute(
2884 &mut workspace,
2885 &ToolCall {
2886 id: "observe-1".into(),
2887 name: "glass.browser.observe".into(),
2888 arguments: serde_json::json!({}),
2889 },
2890 &ToolAuthorization::read_only(Actor::embedded()),
2891 )
2892 .unwrap();
2893 assert_eq!(result["browserRevision"], 42);
2894 assert_eq!(result["structured"], true);
2895 assert!(
2896 !gateway
2897 .descriptors()
2898 .into_iter()
2899 .find(|item| item.name == "glass.browser.act")
2900 .unwrap()
2901 .available
2902 );
2903 let _ = fs::remove_dir_all(root);
2904 }
2905
2906 #[test]
2907 fn tool_argument_evidence_is_streamed_once_and_stays_canonical() {
2908 let registry = ToolRegistry;
2909 let descriptor = registry
2910 .descriptors()
2911 .into_iter()
2912 .find(|descriptor| descriptor.name == "glass.file.read")
2913 .unwrap();
2914 let arguments = serde_json::json!({"path":"src/lib.rs"});
2915 let evidence = validate_tool_arguments(&descriptor, &arguments).unwrap();
2916 let canonical = serde_json::to_vec(&arguments).unwrap();
2917 assert_eq!(evidence.bytes, canonical.len());
2918 assert_eq!(evidence.sha256, digest_hex(&Sha256::digest(&canonical)));
2919
2920 let oversized = serde_json::json!({"path":"x".repeat(MAX_TOOL_ARGUMENT_BYTES)});
2921 let error = validate_tool_arguments(&descriptor, &oversized)
2922 .err()
2923 .expect("oversized arguments must fail");
2924 assert!(error.to_string().contains("tool arguments exceed"));
2925 }
2926
2927 #[test]
2928 fn semantic_context_resolves_explicit_references_without_dumping_file_contents() {
2929 let root = std::env::temp_dir().join(format!("glass-context-{}", std::process::id()));
2930 let _ = fs::remove_dir_all(&root);
2931 fs::create_dir_all(&root).unwrap();
2932 fs::write(root.join("secret.txt"), "do not inline this source").unwrap();
2933 let mut workspace = ProjectWorkspace::open(&root).unwrap();
2934 let packet =
2935 resolve_context(&mut workspace, "Inspect @workspace and @file:secret.txt").unwrap();
2936 let serialized = serde_json::to_string(&packet).unwrap();
2937 assert!(!serialized.contains("do not inline this source"));
2938 assert_eq!(packet.references.len(), 2);
2939 }
2940}