1use crate::development::{Actor, ToolAuthorization, ToolCall};
4use crate::{
5 DevelopmentToolContext, DevelopmentWorkspace, ResidentAgentBroker, WorkspaceTrustStore,
6};
7use glass_browser::cli::args::DaemonCommand;
8use serde::{Deserialize, Serialize};
9use serde_json::Value;
10use std::cell::RefCell;
11use std::collections::{BTreeMap, VecDeque};
12use std::path::{Path, PathBuf};
13use std::rc::Rc;
14use std::time::{Duration, SystemTime, UNIX_EPOCH};
15use tokio::io::{AsyncBufReadExt, AsyncRead, AsyncWrite, AsyncWriteExt, BufReader};
16
17const PROTOCOL_VERSION: u32 = 1;
18const MAX_REQUEST_BYTES: usize = 1024 * 1024;
19const MAX_RESPONSE_BYTES: usize = 1024 * 1024;
20const MAX_WORKSPACES: usize = 8;
21const MAX_CLIENTS: usize = 16;
22const WORKSPACE_COMMAND_CAPACITY: usize = 64;
23const WORKSPACE_EVENT_CAPACITY: usize = 512;
24const MAX_EVENT_BATCH: usize = 256;
25const DAEMON_REQUEST_TIMEOUT: Duration = Duration::from_secs(10);
26
27type WorkspaceRegistry = Rc<RefCell<BTreeMap<String, WorkspaceActorHandle>>>;
28
29#[derive(Clone)]
30struct WorkspaceActorHandle {
31 sender: tokio::sync::mpsc::Sender<WorkspaceCommand>,
32 summary: Value,
33}
34
35enum WorkspaceCommand {
36 Inspect {
37 response: tokio::sync::oneshot::Sender<Result<Value, String>>,
38 },
39 Tool {
40 call: ToolCall,
41 context: Box<DevelopmentToolContext>,
42 response: tokio::sync::oneshot::Sender<Result<Value, String>>,
43 },
44 Events {
45 since: u64,
46 limit: usize,
47 response: tokio::sync::oneshot::Sender<Value>,
48 },
49 Shutdown {
50 response: tokio::sync::oneshot::Sender<()>,
51 },
52}
53
54#[derive(Debug, Clone, Serialize, Deserialize)]
55#[serde(rename_all = "camelCase")]
56pub struct DevelopmentDaemonStatus {
57 pub protocol_version: u32,
58 pub state: String,
59 pub pid: u32,
60 pub socket: PathBuf,
61 pub status_path: PathBuf,
62 pub token_path: PathBuf,
63 pub started_at_ms: u128,
64 pub workspace_count: usize,
65 pub client_count: usize,
66}
67
68#[derive(Debug, Clone, Serialize, Deserialize)]
69#[serde(rename_all = "camelCase")]
70pub struct DevelopmentDaemonRequest {
71 pub id: String,
72 pub token: String,
73 pub operation: String,
74 pub workspace_id: Option<String>,
75 pub root: Option<PathBuf>,
76 pub call: Option<ToolCall>,
77 pub expected_generation: Option<u64>,
78 pub expected_project_revision: Option<u64>,
79 #[serde(default)]
80 pub allow_mutation: bool,
81 #[serde(default)]
82 pub confirmed: bool,
83 pub actor: Option<String>,
84 #[serde(default)]
85 pub since: Option<u64>,
86 #[serde(default)]
87 pub limit: Option<usize>,
88}
89
90#[derive(Debug, Clone, Serialize, Deserialize)]
91#[serde(rename_all = "camelCase")]
92pub struct DevelopmentDaemonEvent {
93 pub sequence: u64,
94 pub timestamp_ms: u128,
95 pub kind: String,
96 pub workspace_id: String,
97 pub tool_call_id: Option<String>,
98 pub success: bool,
99}
100
101#[derive(Debug, Clone, Serialize, Deserialize)]
102#[serde(rename_all = "camelCase")]
103pub struct DevelopmentDaemonResponse {
104 pub id: String,
105 pub ok: bool,
106 pub result: Value,
107 pub error: Option<String>,
108}
109
110pub async fn dispatch(action: &DaemonCommand) -> Result<(), Box<dyn std::error::Error>> {
111 match action {
112 DaemonCommand::Start { socket, status } => {
113 println!(
114 "{}",
115 serde_json::to_string_pretty(&start(socket.as_deref(), status.as_deref()).await?)?
116 );
117 }
118 DaemonCommand::Status { socket, status } | DaemonCommand::Doctor { socket, status } => {
119 println!(
120 "{}",
121 serde_json::to_string_pretty(&read_status_checked(
122 socket.as_deref(),
123 status.as_deref()
124 )?)?
125 );
126 }
127 DaemonCommand::Stop { socket, status } => {
128 stop(socket.as_deref(), status.as_deref())?;
129 println!("{{\"status\":\"stopped\"}}");
130 }
131 DaemonCommand::Logs { status } => {
132 let (_, default_status) = default_paths();
133 let status = status.as_deref().unwrap_or(&default_status);
134 print!("{}", bounded_log(status)?);
135 }
136 DaemonCommand::AcknowledgeRecovery { .. } => {
137 println!("{{\"status\":\"no-recovery-required\"}}");
138 }
139 DaemonCommand::Serve { socket, status } => serve(socket, status).await?,
140 }
141 Ok(())
142}
143
144pub fn default_paths() -> (PathBuf, PathBuf) {
145 #[cfg(windows)]
146 let base =
147 dirs::data_local_dir().unwrap_or_else(|| std::env::temp_dir().join("glass-current-user"));
148 #[cfg(not(windows))]
149 let base = std::env::var_os("XDG_RUNTIME_DIR")
150 .map(PathBuf::from)
151 .or_else(|| std::env::var_os("XDG_DATA_HOME").map(PathBuf::from))
152 .unwrap_or_else(|| std::env::temp_dir().join(format!("glass-{}", effective_uid())));
153 let root = base.join("glass-dev");
154 #[cfg(windows)]
155 {
156 use std::hash::{Hash, Hasher};
157 let mut hasher = std::hash::DefaultHasher::new();
158 root.hash(&mut hasher);
159 let endpoint = PathBuf::from(format!(r"\\.\pipe\glass-dev-{:016x}", hasher.finish()));
160 (endpoint, root.join("glassd.json"))
161 }
162 #[cfg(not(windows))]
163 {
164 (root.join("glassd.sock"), root.join("glassd.json"))
165 }
166}
167
168pub async fn start(
169 socket: Option<&Path>,
170 status_path: Option<&Path>,
171) -> Result<DevelopmentDaemonStatus, Box<dyn std::error::Error>> {
172 #[cfg(not(any(unix, windows)))]
173 {
174 let _ = (socket, status_path);
175 return Err("the durable development daemon currently requires Unix local sockets".into());
176 }
177 #[cfg(unix)]
178 {
179 let (default_socket, default_status) = default_paths();
180 let socket = socket.unwrap_or(&default_socket);
181 let status_path = status_path.unwrap_or(&default_status);
182 if let Ok(existing) = read_status(status_path)
183 && process_alive(existing.pid)
184 {
185 return Err(
186 format!("development daemon is already running as {}", existing.pid).into(),
187 );
188 }
189 remove_socket_if_safe(socket)?;
190 if status_path.exists() {
191 std::fs::remove_file(status_path)?;
192 }
193 std::fs::create_dir_all(socket.parent().unwrap_or_else(|| Path::new(".")))?;
194 std::fs::create_dir_all(status_path.parent().unwrap_or_else(|| Path::new(".")))?;
195 let log = log_path(status_path);
196 let stdout = std::fs::OpenOptions::new()
197 .create(true)
198 .append(true)
199 .open(&log)?;
200 let stderr = stdout.try_clone()?;
201 std::process::Command::new(std::env::current_exe()?)
202 .args(["daemon", "serve"])
203 .arg("--socket")
204 .arg(socket)
205 .arg("--status")
206 .arg(status_path)
207 .stdin(std::process::Stdio::null())
208 .stdout(std::process::Stdio::from(stdout))
209 .stderr(std::process::Stdio::from(stderr))
210 .spawn()?;
211 let deadline = std::time::Instant::now() + Duration::from_secs(3);
212 loop {
213 if let Ok(status) = read_status(status_path)
214 && process_alive(status.pid)
215 && status.socket == socket
216 {
217 return Ok(status);
218 }
219 if std::time::Instant::now() >= deadline {
220 return Err("development daemon did not become ready within three seconds".into());
221 }
222 tokio::time::sleep(Duration::from_millis(25)).await;
223 }
224 }
225 #[cfg(windows)]
226 {
227 let (default_socket, default_status) = default_paths();
228 let socket = socket.unwrap_or(&default_socket);
229 let status_path = status_path.unwrap_or(&default_status);
230 validate_windows_pipe_name(socket)?;
231 if let Ok(existing) = read_status(status_path)
232 && process_alive(existing.pid)
233 {
234 return Err(
235 format!("development daemon is already running as {}", existing.pid).into(),
236 );
237 }
238 if status_path.exists() {
239 std::fs::remove_file(status_path)?;
240 }
241 std::fs::create_dir_all(status_path.parent().unwrap_or_else(|| Path::new(".")))?;
242 let log = log_path(status_path);
243 let stdout = std::fs::OpenOptions::new()
244 .create(true)
245 .append(true)
246 .open(&log)?;
247 let stderr = stdout.try_clone()?;
248 std::process::Command::new(std::env::current_exe()?)
249 .args(["daemon", "serve"])
250 .arg("--socket")
251 .arg(socket)
252 .arg("--status")
253 .arg(status_path)
254 .stdin(std::process::Stdio::null())
255 .stdout(std::process::Stdio::from(stdout))
256 .stderr(std::process::Stdio::from(stderr))
257 .spawn()?;
258 let deadline = std::time::Instant::now() + Duration::from_secs(3);
259 loop {
260 if let Ok(status) = read_status(status_path)
261 && process_alive(status.pid)
262 && status.socket == socket
263 {
264 return Ok(status);
265 }
266 if std::time::Instant::now() >= deadline {
267 return Err("development daemon did not become ready within three seconds".into());
268 }
269 tokio::time::sleep(Duration::from_millis(25)).await;
270 }
271 }
272}
273
274pub fn read_status_checked(
275 socket: Option<&Path>,
276 status_path: Option<&Path>,
277) -> Result<DevelopmentDaemonStatus, Box<dyn std::error::Error>> {
278 let (default_socket, default_status) = default_paths();
279 let expected_socket = socket.unwrap_or(&default_socket);
280 let status_path = status_path.unwrap_or(&default_status);
281 let mut status = read_status(status_path)?;
282 validate_status(&status, status_path)?;
283 if status.socket != expected_socket {
284 return Err("daemon status socket does not match the requested socket".into());
285 }
286 if !process_alive(status.pid) {
287 status.state = "stopped".into();
288 }
289 Ok(status)
290}
291
292pub fn stop(
293 socket: Option<&Path>,
294 status_path: Option<&Path>,
295) -> Result<(), Box<dyn std::error::Error>> {
296 #[cfg(not(any(unix, windows)))]
297 {
298 let _ = (socket, status_path);
299 return Err("the durable development daemon currently requires Unix".into());
300 }
301 #[cfg(unix)]
302 {
303 let status = read_status_checked(socket, status_path)?;
304 if status.pid == std::process::id() {
305 return Err("refusing to stop the calling process".into());
306 }
307 let result = unsafe { libc::kill(status.pid as i32, libc::SIGTERM) };
308 if result != 0 {
309 return Err(std::io::Error::last_os_error().into());
310 }
311 Ok(())
312 }
313 #[cfg(windows)]
314 {
315 use windows_sys::Win32::System::Threading::{
316 OpenProcess, PROCESS_TERMINATE, TerminateProcess,
317 };
318 let status = read_status_checked(socket, status_path)?;
319 if status.pid == std::process::id() {
320 return Err("refusing to stop the calling process".into());
321 }
322 let process = unsafe { OpenProcess(PROCESS_TERMINATE, 0, status.pid) };
323 if process.is_null() {
324 return Err(std::io::Error::last_os_error().into());
325 }
326 let terminated = unsafe { TerminateProcess(process, 0) };
327 unsafe { windows_sys::Win32::Foundation::CloseHandle(process) };
328 if terminated == 0 {
329 return Err(std::io::Error::last_os_error().into());
330 }
331 Ok(())
332 }
333}
334
335pub async fn serve(socket: &Path, status_path: &Path) -> Result<(), Box<dyn std::error::Error>> {
336 serve_with_store(
337 socket,
338 status_path,
339 WorkspaceTrustStore::platform_default()?,
340 )
341 .await
342}
343
344async fn serve_with_store(
345 socket: &Path,
346 status_path: &Path,
347 trust_store: WorkspaceTrustStore,
348) -> Result<(), Box<dyn std::error::Error>> {
349 #[cfg(not(any(unix, windows)))]
350 {
351 let _ = (socket, status_path);
352 return Err("the durable development daemon currently requires Unix".into());
353 }
354 #[cfg(unix)]
355 {
356 use std::os::unix::fs::PermissionsExt;
357 use tokio::net::UnixListener;
358 use tokio::signal::unix::{SignalKind, signal};
359
360 remove_socket_if_safe(socket)?;
361 std::fs::create_dir_all(socket.parent().unwrap_or_else(|| Path::new(".")))?;
362 std::fs::create_dir_all(status_path.parent().unwrap_or_else(|| Path::new(".")))?;
363 let listener = UnixListener::bind(socket)?;
364 std::fs::set_permissions(socket, std::fs::Permissions::from_mode(0o600))?;
365 let token_path = token_path(status_path);
366 let token = create_token()?;
367 write_private(&token_path, token.as_bytes())?;
368 let status = DevelopmentDaemonStatus {
369 protocol_version: PROTOCOL_VERSION,
370 state: "running".into(),
371 pid: std::process::id(),
372 socket: socket.to_path_buf(),
373 status_path: status_path.to_path_buf(),
374 token_path: token_path.clone(),
375 started_at_ms: now_ms(),
376 workspace_count: 0,
377 client_count: 0,
378 };
379 write_status(status_path, &status)?;
380 let workspaces: WorkspaceRegistry = Rc::new(RefCell::new(BTreeMap::new()));
381 let clients = std::rc::Rc::new(std::cell::Cell::new(0_usize));
382 let local = tokio::task::LocalSet::new();
383 let mut terminate = signal(SignalKind::terminate())?;
384 local
385 .run_until(async {
386 loop {
387 let (stream, _) = tokio::select! {
388 accepted = listener.accept() => accepted?,
389 _ = terminate.recv() => break,
390 };
391 authorize_local_peer(&stream)?;
392 if clients.get() >= MAX_CLIENTS {
393 continue;
394 }
395 clients.set(clients.get() + 1);
396 update_counts(status_path, workspaces.borrow().len(), clients.get())?;
397 let workspaces = Rc::clone(&workspaces);
398 let clients = Rc::clone(&clients);
399 let token = token.clone();
400 let status_path = status_path.to_path_buf();
401 let socket = socket.to_path_buf();
402 let trust_store = trust_store.clone();
403 tokio::task::spawn_local(async move {
404 if let Err(error) =
405 handle_client(stream, &token, &socket, &workspaces, &trust_store).await
406 {
407 tracing::warn!(%error, "development daemon client failed");
408 }
409 clients.set(clients.get().saturating_sub(1));
410 let workspace_count = workspaces.borrow().len();
411 let _ = update_counts(&status_path, workspace_count, clients.get());
412 });
413 }
414 Ok::<(), Box<dyn std::error::Error>>(())
415 })
416 .await?;
417 let _ = std::fs::remove_file(status_path);
418 let _ = std::fs::remove_file(token_path);
419 remove_socket_if_safe(socket)?;
420 Ok(())
421 }
422 #[cfg(windows)]
423 {
424 use tokio::net::windows::named_pipe::ServerOptions;
425
426 validate_windows_pipe_name(socket)?;
427 std::fs::create_dir_all(status_path.parent().unwrap_or_else(|| Path::new(".")))?;
428 let token_path = token_path(status_path);
429 let token = create_token()?;
430 write_private(&token_path, token.as_bytes())?;
431 let status = DevelopmentDaemonStatus {
432 protocol_version: PROTOCOL_VERSION,
433 state: "running".into(),
434 pid: std::process::id(),
435 socket: socket.to_path_buf(),
436 status_path: status_path.to_path_buf(),
437 token_path: token_path.clone(),
438 started_at_ms: now_ms(),
439 workspace_count: 0,
440 client_count: 0,
441 };
442 write_status(status_path, &status)?;
443 let workspaces: WorkspaceRegistry = Rc::new(RefCell::new(BTreeMap::new()));
444 let clients = Rc::new(std::cell::Cell::new(0_usize));
445 let local = tokio::task::LocalSet::new();
446 let pipe_name = socket.to_string_lossy().to_string();
447 local
448 .run_until(async {
449 let mut first = true;
450 loop {
451 let server = ServerOptions::new()
452 .first_pipe_instance(first)
453 .reject_remote_clients(true)
454 .create(&pipe_name)?;
455 first = false;
456 tokio::select! {
457 connected = server.connect() => connected?,
458 _ = tokio::signal::ctrl_c() => break,
459 }
460 if clients.get() >= MAX_CLIENTS {
461 continue;
462 }
463 clients.set(clients.get() + 1);
464 update_counts(status_path, workspaces.borrow().len(), clients.get())?;
465 let workspaces = Rc::clone(&workspaces);
466 let clients = Rc::clone(&clients);
467 let token = token.clone();
468 let status_path = status_path.to_path_buf();
469 let socket = socket.to_path_buf();
470 let trust_store = trust_store.clone();
471 tokio::task::spawn_local(async move {
472 if let Err(error) =
473 handle_stream(server, &token, &socket, &workspaces, &trust_store).await
474 {
475 tracing::warn!(%error, "development daemon named-pipe client failed");
476 }
477 clients.set(clients.get().saturating_sub(1));
478 let _ =
479 update_counts(&status_path, workspaces.borrow().len(), clients.get());
480 });
481 }
482 Ok::<(), Box<dyn std::error::Error>>(())
483 })
484 .await?;
485 let _ = std::fs::remove_file(status_path);
486 let _ = std::fs::remove_file(token_path);
487 Ok(())
488 }
489}
490
491#[cfg(unix)]
492async fn handle_client(
493 stream: tokio::net::UnixStream,
494 token: &str,
495 socket: &Path,
496 workspaces: &WorkspaceRegistry,
497 trust_store: &WorkspaceTrustStore,
498) -> Result<(), Box<dyn std::error::Error>> {
499 handle_stream(stream, token, socket, workspaces, trust_store).await
500}
501
502async fn handle_stream<S>(
503 stream: S,
504 token: &str,
505 socket: &Path,
506 workspaces: &WorkspaceRegistry,
507 trust_store: &WorkspaceTrustStore,
508) -> Result<(), Box<dyn std::error::Error>>
509where
510 S: AsyncRead + AsyncWrite + Unpin,
511{
512 let (read, mut write) = tokio::io::split(stream);
513 let mut lines = BufReader::new(read).lines();
514 while let Some(line) = lines.next_line().await? {
515 let response = if line.len() > MAX_REQUEST_BYTES {
516 DevelopmentDaemonResponse {
517 id: "oversized".into(),
518 ok: false,
519 result: Value::Null,
520 error: Some("daemon request exceeds the size limit".into()),
521 }
522 } else {
523 match serde_json::from_str::<DevelopmentDaemonRequest>(&line) {
524 Ok(request) => {
525 execute_request(request, token, socket, workspaces, trust_store).await
526 }
527 Err(error) => DevelopmentDaemonResponse {
528 id: "invalid".into(),
529 ok: false,
530 result: Value::Null,
531 error: Some(format!("invalid daemon request: {error}")),
532 },
533 }
534 };
535 let encoded = serde_json::to_vec(&response)?;
536 if encoded.len() > MAX_RESPONSE_BYTES {
537 return Err("daemon response exceeds the size limit".into());
538 }
539 write.write_all(&encoded).await?;
540 write.write_all(b"\n").await?;
541 write.flush().await?;
542 }
543 Ok(())
544}
545
546async fn execute_request(
547 request: DevelopmentDaemonRequest,
548 token: &str,
549 socket: &Path,
550 workspaces: &WorkspaceRegistry,
551 trust_store: &WorkspaceTrustStore,
552) -> DevelopmentDaemonResponse {
553 let id = request.id.clone();
554 let result = async {
555 validate_request(&request, token)?;
556 match request.operation.as_str() {
557 "ping" => Ok(serde_json::json!({"protocolVersion":PROTOCOL_VERSION})),
558 "workspace.list" => Ok(Value::Array(
559 workspaces
560 .borrow()
561 .values()
562 .map(|handle| handle.summary.clone())
563 .collect(),
564 )),
565 "workspace.open" => {
566 let workspace_id = required_workspace_id(&request)?;
567 let root = request
568 .root
569 .as_deref()
570 .ok_or("workspace.open requires root")?;
571 if workspaces.borrow().contains_key(workspace_id) {
572 return Err("workspace identity is already open".into());
573 }
574 if workspaces.borrow().len() >= MAX_WORKSPACES {
575 return Err("daemon workspace quota reached".into());
576 }
577 let mut workspace =
578 DevelopmentWorkspace::open_with_store(root, trust_store.clone())
579 .map_err(|error| error.to_string())?;
580 workspace
581 .agents()
582 .set_resident_broker(ResidentAgentBroker {
583 socket: socket.to_path_buf(),
584 token: token.to_string(),
585 workspace_id: workspace_id.to_string(),
586 })
587 .map_err(|error| error.to_string())?;
588 let result = workspace_summary(workspace_id, &workspace);
589 let (sender, receiver) = tokio::sync::mpsc::channel(WORKSPACE_COMMAND_CAPACITY);
590 tokio::task::spawn_local(run_workspace_actor(
591 workspace_id.into(),
592 workspace,
593 receiver,
594 ));
595 let mut state = workspaces.borrow_mut();
596 if state.contains_key(workspace_id) || state.len() >= MAX_WORKSPACES {
597 return Err("daemon workspace registry changed while opening".into());
598 }
599 state.insert(
600 workspace_id.into(),
601 WorkspaceActorHandle {
602 sender,
603 summary: result.clone(),
604 },
605 );
606 Ok(result)
607 }
608 "workspace.inspect" => {
609 let workspace_id = required_workspace_id(&request)?;
610 workspace_inspect(workspace_handle(workspaces, workspace_id)?).await
611 }
612 "workspace.tool" => {
613 let workspace_id = required_workspace_id(&request)?;
614 let call = request
615 .call
616 .as_ref()
617 .ok_or("workspace.tool requires call")?;
618 let actor = request
619 .actor
620 .as_deref()
621 .map(Actor::external)
622 .unwrap_or_else(Actor::local);
623 let context = DevelopmentToolContext {
624 authorization: ToolAuthorization {
625 actor,
626 allow_mutation: request.allow_mutation,
627 confirmed: request.confirmed,
628 },
629 initiator: None,
630 expected_generation: request
631 .expected_generation
632 .ok_or("workspace.tool requires expectedGeneration")?,
633 expected_project_revision: request
634 .expected_project_revision
635 .ok_or("workspace.tool requires expectedProjectRevision")?,
636 };
637 workspace_tool(
638 workspace_handle(workspaces, workspace_id)?,
639 call.clone(),
640 context,
641 )
642 .await
643 }
644 "workspace.events" => {
645 let workspace_id = required_workspace_id(&request)?;
646 workspace_events(
647 workspace_handle(workspaces, workspace_id)?,
648 request.since.unwrap_or(0),
649 request.limit.unwrap_or(128),
650 )
651 .await
652 }
653 "workspace.close" => {
654 let workspace_id = required_workspace_id(&request)?;
655 let handle = workspaces.borrow_mut().remove(workspace_id);
656 if let Some(handle) = handle {
657 let (response, received) = tokio::sync::oneshot::channel();
658 handle
659 .sender
660 .send(WorkspaceCommand::Shutdown { response })
661 .await
662 .map_err(|_| "workspace actor command queue closed")?;
663 received.await.map_err(|_| "workspace actor did not stop")?;
664 Ok(serde_json::json!({"closed":true}))
665 } else {
666 Ok(serde_json::json!({"closed":false}))
667 }
668 }
669 _ => Err("unknown daemon operation".into()),
670 }
671 }
672 .await;
673 match result {
674 Ok(result) => DevelopmentDaemonResponse {
675 id,
676 ok: true,
677 result,
678 error: None,
679 },
680 Err(error) => DevelopmentDaemonResponse {
681 id,
682 ok: false,
683 result: Value::Null,
684 error: Some(error),
685 },
686 }
687}
688
689fn workspace_handle(
690 workspaces: &WorkspaceRegistry,
691 workspace_id: &str,
692) -> Result<WorkspaceActorHandle, String> {
693 workspaces
694 .borrow()
695 .get(workspace_id)
696 .cloned()
697 .ok_or_else(|| "unknown durable workspace".into())
698}
699
700async fn workspace_inspect(handle: WorkspaceActorHandle) -> Result<Value, String> {
701 let (response, received) = tokio::sync::oneshot::channel();
702 handle
703 .sender
704 .send(WorkspaceCommand::Inspect { response })
705 .await
706 .map_err(|_| "workspace actor command queue closed")?;
707 received
708 .await
709 .map_err(|_| "workspace actor dropped its inspect response")?
710}
711
712async fn workspace_tool(
713 handle: WorkspaceActorHandle,
714 call: ToolCall,
715 context: DevelopmentToolContext,
716) -> Result<Value, String> {
717 let (response, received) = tokio::sync::oneshot::channel();
718 handle
719 .sender
720 .send(WorkspaceCommand::Tool {
721 call,
722 context: Box::new(context),
723 response,
724 })
725 .await
726 .map_err(|_| "workspace actor command queue closed")?;
727 received
728 .await
729 .map_err(|_| "workspace actor dropped its tool response")?
730}
731
732async fn workspace_events(
733 handle: WorkspaceActorHandle,
734 since: u64,
735 limit: usize,
736) -> Result<Value, String> {
737 if limit == 0 || limit > MAX_EVENT_BATCH {
738 return Err(format!(
739 "workspace event limit must be 1..={MAX_EVENT_BATCH}"
740 ));
741 }
742 let (response, received) = tokio::sync::oneshot::channel();
743 handle
744 .sender
745 .send(WorkspaceCommand::Events {
746 since,
747 limit,
748 response,
749 })
750 .await
751 .map_err(|_| "workspace actor command queue closed")?;
752 received
753 .await
754 .map_err(|_| "workspace actor dropped its event response".into())
755}
756
757async fn run_workspace_actor(
758 workspace_id: String,
759 workspace: DevelopmentWorkspace,
760 mut commands: tokio::sync::mpsc::Receiver<WorkspaceCommand>,
761) {
762 let mut workspace = Some(workspace);
763 let mut events = VecDeque::with_capacity(WORKSPACE_EVENT_CAPACITY);
764 let mut next_event = 1_u64;
765 let mut dropped_events = 0_u64;
766 push_workspace_event(
767 &workspace_id,
768 &mut events,
769 &mut next_event,
770 &mut dropped_events,
771 "workspace.opened",
772 None,
773 true,
774 );
775 let mut tick = tokio::time::interval(Duration::from_millis(50));
776 tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
777 loop {
778 tokio::select! {
779 biased;
780 command = commands.recv() => match command {
781 Some(WorkspaceCommand::Inspect { response }) => {
782 let result = inspect_workspace(
783 &workspace_id,
784 workspace.as_mut().expect("workspace actor retains ownership"),
785 );
786 let _ = response.send(result);
787 }
788 Some(WorkspaceCommand::Tool { call, context, response }) => {
789 let kind = daemon_event_kind(&call.name);
790 let mut owned_workspace = workspace
791 .take()
792 .expect("workspace actor retains ownership");
793 let execution = tokio::task::spawn_blocking(move || {
794 let result = owned_workspace
795 .execute_tool(&call, &context)
796 .map_err(|error| error.to_string());
797 (owned_workspace, call.id, result)
798 })
799 .await;
800 let (returned_workspace, call_id, result) = match execution {
801 Ok(execution) => execution,
802 Err(error) => {
803 let _ = response.send(Err(format!(
804 "workspace actor tool execution failed: {error}"
805 )));
806 break;
807 }
808 };
809 workspace = Some(returned_workspace);
810 push_workspace_event(
811 &workspace_id,
812 &mut events,
813 &mut next_event,
814 &mut dropped_events,
815 kind,
816 Some(call_id),
817 result.is_ok(),
818 );
819 let _ = response.send(result);
820 }
821 Some(WorkspaceCommand::Events { since, limit, response }) => {
822 let _ = response.send(workspace_event_batch(
823 &events,
824 next_event,
825 dropped_events,
826 since,
827 limit,
828 ));
829 }
830 Some(WorkspaceCommand::Shutdown { response }) => {
831 let _ = response.send(());
832 break;
833 }
834 None => break,
835 },
836 _ = tick.tick() => {
837 if let Err(error) = workspace
838 .as_mut()
839 .expect("workspace actor retains ownership")
840 .tasks()
841 {
842 tracing::warn!(workspace_id, %error, "workspace task scheduler tick failed");
843 }
844 }
845 }
846 }
847}
848
849fn workspace_event_batch(
850 events: &VecDeque<DevelopmentDaemonEvent>,
851 next_event: u64,
852 dropped_events: u64,
853 since: u64,
854 limit: usize,
855) -> Value {
856 let oldest = events
857 .front()
858 .map(|event| event.sequence)
859 .unwrap_or(next_event);
860 let newest = events.back().map(|event| event.sequence).unwrap_or(0);
861 let selected = events
862 .iter()
863 .filter(|event| event.sequence > since)
864 .take(limit)
865 .cloned()
866 .collect::<Vec<_>>();
867 serde_json::json!({
868 "events": selected,
869 "oldestSequence": oldest,
870 "newestSequence": newest,
871 "lostBefore": (since.saturating_add(1) < oldest).then_some(oldest),
872 "droppedEvents": dropped_events,
873 "capacity": WORKSPACE_EVENT_CAPACITY,
874 })
875}
876
877fn push_workspace_event(
878 workspace_id: &str,
879 events: &mut VecDeque<DevelopmentDaemonEvent>,
880 next_event: &mut u64,
881 dropped_events: &mut u64,
882 kind: &str,
883 tool_call_id: Option<String>,
884 success: bool,
885) {
886 if events.len() == WORKSPACE_EVENT_CAPACITY {
887 events.pop_front();
888 *dropped_events = dropped_events.saturating_add(1);
889 }
890 events.push_back(DevelopmentDaemonEvent {
891 sequence: *next_event,
892 timestamp_ms: now_ms(),
893 kind: kind.into(),
894 workspace_id: workspace_id.into(),
895 tool_call_id,
896 success,
897 });
898 *next_event = next_event.saturating_add(1);
899}
900
901fn daemon_event_kind(tool: &str) -> &'static str {
902 if tool.starts_with("glass.agent.") {
903 "agent.event"
904 } else if tool.starts_with("glass.task.") {
905 "task.changed"
906 } else if tool.starts_with("glass.process.") {
907 "process.output"
908 } else if tool.starts_with("glass.browser.") || tool.starts_with("glass.web.") {
909 "browser.revision"
910 } else if tool.starts_with("glass.lsp.") {
911 "lsp.diagnostics"
912 } else if tool.starts_with("glass.debug.") {
913 "debugger.stopped"
914 } else if tool.starts_with("glass.test.") || tool.starts_with("glass.workflow.") {
915 "test.completed"
916 } else if tool.starts_with("glass.git.") {
917 "git.changed"
918 } else if tool.starts_with("glass.experiment.") {
919 "experiment.changed"
920 } else {
921 "workspace.changed"
922 }
923}
924
925fn inspect_workspace(
926 workspace_id: &str,
927 workspace: &mut DevelopmentWorkspace,
928) -> Result<Value, String> {
929 let agents = workspace
930 .agents()
931 .list()
932 .map_err(|error| error.to_string())?;
933 let tasks = workspace.tasks().map_err(|error| error.to_string())?;
934 let processes = workspace
935 .project_mut()
936 .processes()
937 .list_checked()
938 .map_err(|error| error.to_string())?;
939 Ok(serde_json::json!({
940 "workspace":workspace_summary(workspace_id, workspace),
941 "processes":processes,
942 "agents":agents,
943 "tasks":tasks,
944 "kernels":workspace.kernels().snapshots().collect::<Vec<_>>(),
945 "debuggers":workspace.debugger_names().collect::<Vec<_>>(),
946 "browser":workspace.browser().state().map_err(|error| error.to_string())?
947 }))
948}
949
950#[cfg(unix)]
951pub async fn request(
952 socket: &Path,
953 request: &DevelopmentDaemonRequest,
954) -> Result<DevelopmentDaemonResponse, Box<dyn std::error::Error>> {
955 let stream = tokio::net::UnixStream::connect(socket).await?;
956 bounded_request_stream(stream, request).await
957}
958
959#[cfg(windows)]
960pub async fn request(
961 socket: &Path,
962 request: &DevelopmentDaemonRequest,
963) -> Result<DevelopmentDaemonResponse, Box<dyn std::error::Error>> {
964 use tokio::net::windows::named_pipe::ClientOptions;
965 validate_windows_pipe_name(socket)?;
966 let deadline = std::time::Instant::now() + Duration::from_secs(3);
967 let pipe_name = socket.to_string_lossy();
968 let stream = loop {
969 match ClientOptions::new().open(pipe_name.as_ref()) {
970 Ok(stream) => break stream,
971 Err(error)
972 if error.raw_os_error() == Some(231) && std::time::Instant::now() < deadline =>
973 {
974 tokio::time::sleep(Duration::from_millis(10)).await;
975 }
976 Err(error) => return Err(error.into()),
977 }
978 };
979 bounded_request_stream(stream, request).await
980}
981
982async fn bounded_request_stream<S>(
983 stream: S,
984 request: &DevelopmentDaemonRequest,
985) -> Result<DevelopmentDaemonResponse, Box<dyn std::error::Error>>
986where
987 S: AsyncRead + AsyncWrite + Unpin,
988{
989 tokio::time::timeout(DAEMON_REQUEST_TIMEOUT, request_stream(stream, request))
990 .await
991 .map_err(|_| {
992 format!(
993 "daemon operation {} timed out after {} seconds",
994 request.operation,
995 DAEMON_REQUEST_TIMEOUT.as_secs()
996 )
997 })?
998}
999
1000async fn request_stream<S>(
1001 stream: S,
1002 request: &DevelopmentDaemonRequest,
1003) -> Result<DevelopmentDaemonResponse, Box<dyn std::error::Error>>
1004where
1005 S: AsyncRead + AsyncWrite + Unpin,
1006{
1007 let (read, mut write) = tokio::io::split(stream);
1008 let encoded = serde_json::to_vec(request)?;
1009 if encoded.len() > MAX_REQUEST_BYTES {
1010 return Err("daemon request exceeds the size limit".into());
1011 }
1012 write.write_all(&encoded).await?;
1013 write.write_all(b"\n").await?;
1014 write.flush().await?;
1015 let mut line = String::new();
1016 BufReader::new(read).read_line(&mut line).await?;
1017 Ok(serde_json::from_str(&line)?)
1018}
1019
1020#[cfg(not(any(unix, windows)))]
1021pub async fn request(
1022 _socket: &Path,
1023 _request: &DevelopmentDaemonRequest,
1024) -> Result<DevelopmentDaemonResponse, Box<dyn std::error::Error>> {
1025 Err("the local development daemon requires Unix-domain sockets on this platform".into())
1026}
1027
1028pub async fn forward_resident_tool_file(
1029 path: &Path,
1030 root: &Path,
1031 allow_mutation: bool,
1032 confirmed: bool,
1033) -> Result<Value, Box<dyn std::error::Error>> {
1034 let socket = PathBuf::from(
1035 std::env::var_os("GLASS_DEV_DAEMON_SOCKET")
1036 .ok_or("resident Pi broker socket is missing")?,
1037 );
1038 let token = std::env::var("GLASS_DEV_DAEMON_TOKEN")
1039 .map_err(|_| "resident Pi broker token is missing")?;
1040 let workspace_id = std::env::var("GLASS_DEV_DAEMON_WORKSPACE")
1041 .map_err(|_| "resident Pi broker workspace is missing")?;
1042 forward_resident_tool_file_with_context(
1043 &socket,
1044 &token,
1045 &workspace_id,
1046 path,
1047 root,
1048 allow_mutation,
1049 confirmed,
1050 )
1051 .await
1052}
1053
1054async fn forward_resident_tool_file_with_context(
1055 socket: &Path,
1056 token: &str,
1057 workspace_id: &str,
1058 path: &Path,
1059 root: &Path,
1060 allow_mutation: bool,
1061 confirmed: bool,
1062) -> Result<Value, Box<dyn std::error::Error>> {
1063 let call = read_private_tool_call(path)?;
1064 forward_resident_tool_call(
1065 socket,
1066 token,
1067 workspace_id,
1068 &call,
1069 root,
1070 allow_mutation,
1071 confirmed,
1072 )
1073 .await
1074}
1075
1076pub(crate) async fn forward_resident_tool_call_with_context(
1077 broker: &ResidentAgentBroker,
1078 call: &ToolCall,
1079 root: &Path,
1080 allow_mutation: bool,
1081 confirmed: bool,
1082) -> Result<Value, Box<dyn std::error::Error>> {
1083 forward_resident_tool_call(
1084 &broker.socket,
1085 &broker.token,
1086 &broker.workspace_id,
1087 call,
1088 root,
1089 allow_mutation,
1090 confirmed,
1091 )
1092 .await
1093}
1094
1095async fn forward_resident_tool_call(
1096 socket: &Path,
1097 token: &str,
1098 workspace_id: &str,
1099 call: &ToolCall,
1100 root: &Path,
1101 allow_mutation: bool,
1102 confirmed: bool,
1103) -> Result<Value, Box<dyn std::error::Error>> {
1104 let inspect = request(
1105 socket,
1106 &DevelopmentDaemonRequest {
1107 id: format!("inspect-{}", call.id),
1108 token: token.to_string(),
1109 operation: "workspace.inspect".into(),
1110 workspace_id: Some(workspace_id.to_string()),
1111 root: None,
1112 call: None,
1113 expected_generation: None,
1114 expected_project_revision: None,
1115 allow_mutation: false,
1116 confirmed: false,
1117 actor: Some("pi".into()),
1118 since: None,
1119 limit: None,
1120 },
1121 )
1122 .await?;
1123 if !inspect.ok {
1124 return Err(inspect
1125 .error
1126 .unwrap_or_else(|| "workspace inspect failed".into())
1127 .into());
1128 }
1129 let expected_root = std::fs::canonicalize(root)?;
1130 let observed_root = inspect
1131 .result
1132 .pointer("/workspace/root")
1133 .and_then(Value::as_str);
1134 if observed_root != expected_root.to_str() {
1135 return Err("resident Pi broker root does not match the durable workspace".into());
1136 }
1137 let generation = inspect
1138 .result
1139 .pointer("/workspace/generation")
1140 .and_then(Value::as_u64)
1141 .ok_or("durable workspace generation is missing")?;
1142 let revision = inspect
1143 .result
1144 .pointer("/workspace/projectRevision")
1145 .and_then(Value::as_u64)
1146 .ok_or("durable workspace revision is missing")?;
1147 let response = request(
1148 socket,
1149 &DevelopmentDaemonRequest {
1150 id: format!("tool-{}", call.id),
1151 token: token.to_string(),
1152 operation: "workspace.tool".into(),
1153 workspace_id: Some(workspace_id.to_string()),
1154 root: None,
1155 call: Some(call.clone()),
1156 expected_generation: Some(generation),
1157 expected_project_revision: Some(revision),
1158 allow_mutation,
1159 confirmed,
1160 actor: Some("pi".into()),
1161 since: None,
1162 limit: None,
1163 },
1164 )
1165 .await?;
1166 if response.ok {
1167 Ok(response.result)
1168 } else {
1169 Err(response
1170 .error
1171 .unwrap_or_else(|| "resident tool call failed".into())
1172 .into())
1173 }
1174}
1175
1176pub(crate) fn read_private_tool_call(path: &Path) -> Result<ToolCall, Box<dyn std::error::Error>> {
1177 use std::io::Read;
1178 const MAX_CALL_BYTES: u64 = 256 * 1024;
1179 let canonical = path.canonicalize()?;
1180 let temporary_root = std::env::temp_dir().canonicalize()?;
1181 if canonical.parent() != Some(temporary_root.as_path())
1182 || !canonical
1183 .file_name()
1184 .and_then(|name| name.to_str())
1185 .is_some_and(|name| name.starts_with("glass-pi-call-") && name.ends_with(".json"))
1186 {
1187 return Err("Pi broker requests must use a private Glass temporary file".into());
1188 }
1189 let mut options = std::fs::OpenOptions::new();
1190 options.read(true);
1191 #[cfg(unix)]
1192 {
1193 use std::os::unix::fs::OpenOptionsExt;
1194 options.custom_flags(libc::O_NOFOLLOW);
1195 }
1196 let file = options.open(&canonical)?;
1197 let metadata = file.metadata()?;
1198 if !metadata.is_file() || metadata.len() > MAX_CALL_BYTES {
1199 return Err("invalid Pi broker request file".into());
1200 }
1201 #[cfg(unix)]
1202 {
1203 use std::os::unix::fs::{MetadataExt, PermissionsExt};
1204 if metadata.uid() != unsafe { libc::geteuid() }
1205 || metadata.permissions().mode() & 0o077 != 0
1206 {
1207 return Err("Pi broker request must be owned by this user with mode 0600".into());
1208 }
1209 }
1210 let mut encoded = Vec::with_capacity(metadata.len() as usize);
1211 file.take(MAX_CALL_BYTES + 1).read_to_end(&mut encoded)?;
1212 std::fs::remove_file(&canonical)?;
1213 if encoded.len() as u64 > MAX_CALL_BYTES {
1214 return Err("Pi broker request exceeds the size limit".into());
1215 }
1216 Ok(serde_json::from_slice(&encoded)?)
1217}
1218
1219fn workspace_summary(id: &str, workspace: &DevelopmentWorkspace) -> Value {
1220 serde_json::json!({
1221 "id":id,
1222 "root":workspace.root(),
1223 "trust":workspace.trust(),
1224 "generation":workspace.generation(),
1225 "projectRevision":workspace.project().revision()
1226 })
1227}
1228
1229fn validate_request(request: &DevelopmentDaemonRequest, token: &str) -> Result<(), String> {
1230 if request.token.as_bytes() != token.as_bytes() {
1231 return Err("invalid daemon authentication token".into());
1232 }
1233 validate_identifier(&request.id, "request")?;
1234 if request.operation.is_empty()
1235 || request.operation.len() > 128
1236 || request.operation.chars().any(char::is_control)
1237 {
1238 return Err("invalid daemon operation".into());
1239 }
1240 Ok(())
1241}
1242
1243fn required_workspace_id(request: &DevelopmentDaemonRequest) -> Result<&str, String> {
1244 let id = request
1245 .workspace_id
1246 .as_deref()
1247 .ok_or("daemon request requires workspaceId")?;
1248 validate_identifier(id, "workspace")?;
1249 Ok(id)
1250}
1251
1252fn validate_identifier(value: &str, description: &str) -> Result<(), String> {
1253 if value.is_empty()
1254 || value.len() > 128
1255 || !value
1256 .chars()
1257 .all(|character| character.is_ascii_alphanumeric() || "-_.".contains(character))
1258 {
1259 return Err(format!("invalid {description} identifier"));
1260 }
1261 Ok(())
1262}
1263
1264fn read_status(path: &Path) -> Result<DevelopmentDaemonStatus, Box<dyn std::error::Error>> {
1265 let bytes = std::fs::read(path)?;
1266 if bytes.len() > 64 * 1024 {
1267 return Err("daemon status exceeds the size limit".into());
1268 }
1269 Ok(serde_json::from_slice(&bytes)?)
1270}
1271
1272fn validate_status(
1273 status: &DevelopmentDaemonStatus,
1274 path: &Path,
1275) -> Result<(), Box<dyn std::error::Error>> {
1276 if status.protocol_version != PROTOCOL_VERSION || status.status_path != path {
1277 return Err("invalid development daemon status contract".into());
1278 }
1279 if status.workspace_count > MAX_WORKSPACES || status.client_count > MAX_CLIENTS {
1280 return Err("daemon status exceeds resource quotas".into());
1281 }
1282 Ok(())
1283}
1284
1285fn write_status(
1286 path: &Path,
1287 status: &DevelopmentDaemonStatus,
1288) -> Result<(), Box<dyn std::error::Error>> {
1289 let encoded = serde_json::to_vec_pretty(status)?;
1290 write_private(path, &encoded)
1291}
1292
1293fn update_counts(
1294 status_path: &Path,
1295 workspace_count: usize,
1296 client_count: usize,
1297) -> Result<(), Box<dyn std::error::Error>> {
1298 let mut status = read_status(status_path)?;
1299 status.workspace_count = workspace_count;
1300 status.client_count = client_count;
1301 write_status(status_path, &status)
1302}
1303
1304fn write_private(path: &Path, bytes: &[u8]) -> Result<(), Box<dyn std::error::Error>> {
1305 use std::io::Write;
1306 #[cfg(unix)]
1307 use std::os::unix::fs::OpenOptionsExt;
1308 let temporary = path.with_extension(format!("tmp-{}", std::process::id()));
1309 let mut options = std::fs::OpenOptions::new();
1310 options.create_new(true).write(true);
1311 #[cfg(unix)]
1312 options.mode(0o600);
1313 let mut file = options.open(&temporary)?;
1314 file.write_all(bytes)?;
1315 file.sync_all()?;
1316 std::fs::rename(temporary, path)?;
1317 Ok(())
1318}
1319
1320fn create_token() -> Result<String, Box<dyn std::error::Error>> {
1321 let mut bytes = [0_u8; 32];
1322 getrandom::fill(&mut bytes)?;
1323 Ok(bytes.iter().map(|byte| format!("{byte:02x}")).collect())
1324}
1325
1326fn token_path(status: &Path) -> PathBuf {
1327 status.with_extension("token")
1328}
1329
1330fn log_path(status: &Path) -> PathBuf {
1331 status.with_extension("log")
1332}
1333
1334fn bounded_log(status: &Path) -> Result<String, Box<dyn std::error::Error>> {
1335 use std::io::{Read, Seek, SeekFrom};
1336 let mut file = std::fs::File::open(log_path(status))?;
1337 let length = file.metadata()?.len();
1338 let start = length.saturating_sub(64 * 1024);
1339 file.seek(SeekFrom::Start(start))?;
1340 let mut output = String::new();
1341 file.read_to_string(&mut output)?;
1342 Ok(output)
1343}
1344
1345#[cfg(unix)]
1346fn authorize_local_peer(stream: &tokio::net::UnixStream) -> Result<(), Box<dyn std::error::Error>> {
1347 #[cfg(target_os = "linux")]
1348 {
1349 use std::os::fd::AsRawFd;
1350 let mut credentials = libc::ucred {
1351 pid: 0,
1352 uid: 0,
1353 gid: 0,
1354 };
1355 let mut length = std::mem::size_of::<libc::ucred>() as libc::socklen_t;
1356 let result = unsafe {
1357 libc::getsockopt(
1358 stream.as_raw_fd(),
1359 libc::SOL_SOCKET,
1360 libc::SO_PEERCRED,
1361 (&mut credentials as *mut libc::ucred).cast(),
1362 &mut length,
1363 )
1364 };
1365 if result != 0 || credentials.uid != unsafe { libc::geteuid() } {
1366 return Err("daemon rejected a non-local-user peer".into());
1367 }
1368 }
1369 Ok(())
1370}
1371
1372#[cfg(unix)]
1373fn remove_socket_if_safe(path: &Path) -> Result<(), Box<dyn std::error::Error>> {
1374 use std::os::unix::fs::FileTypeExt;
1375 match std::fs::symlink_metadata(path) {
1376 Ok(metadata) if metadata.file_type().is_socket() => std::fs::remove_file(path)?,
1377 Ok(_) => return Err(format!("refusing to replace non-socket {}", path.display()).into()),
1378 Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
1379 Err(error) => return Err(error.into()),
1380 }
1381 Ok(())
1382}
1383
1384#[cfg(not(unix))]
1385fn remove_socket_if_safe(_path: &Path) -> Result<(), Box<dyn std::error::Error>> {
1386 Ok(())
1387}
1388
1389fn process_alive(pid: u32) -> bool {
1390 #[cfg(unix)]
1391 {
1392 unsafe { libc::kill(pid as i32, 0) == 0 }
1393 }
1394 #[cfg(windows)]
1395 {
1396 use windows_sys::Win32::Foundation::{CloseHandle, STILL_ACTIVE};
1397 use windows_sys::Win32::System::Threading::{
1398 GetExitCodeProcess, OpenProcess, PROCESS_QUERY_LIMITED_INFORMATION,
1399 };
1400 let process = unsafe { OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, 0, pid) };
1401 if process.is_null() {
1402 return false;
1403 }
1404 let mut exit_code = 0_u32;
1405 let success = unsafe { GetExitCodeProcess(process, &mut exit_code) } != 0;
1406 unsafe { CloseHandle(process) };
1407 success && exit_code == STILL_ACTIVE as u32
1408 }
1409 #[cfg(not(any(unix, windows)))]
1410 {
1411 let _ = pid;
1412 false
1413 }
1414}
1415
1416#[cfg(windows)]
1417fn validate_windows_pipe_name(path: &Path) -> Result<(), Box<dyn std::error::Error>> {
1418 let value = path
1419 .to_str()
1420 .ok_or("Windows named-pipe endpoint must be Unicode")?;
1421 if !valid_windows_pipe_name(value) {
1422 return Err("invalid Windows Glass daemon pipe name".into());
1423 }
1424 Ok(())
1425}
1426
1427#[cfg(any(windows, test))]
1428fn valid_windows_pipe_name(value: &str) -> bool {
1429 value
1430 .strip_prefix(r"\\.\pipe\glass-dev-")
1431 .is_some_and(|name| {
1432 !name.is_empty()
1433 && name.len() <= 64
1434 && name
1435 .chars()
1436 .all(|character| character.is_ascii_alphanumeric() || character == '-')
1437 })
1438}
1439
1440fn effective_uid() -> u32 {
1441 #[cfg(unix)]
1442 {
1443 unsafe { libc::geteuid() }
1444 }
1445 #[cfg(not(unix))]
1446 {
1447 0
1448 }
1449}
1450
1451fn now_ms() -> u128 {
1452 SystemTime::now()
1453 .duration_since(UNIX_EPOCH)
1454 .unwrap_or_default()
1455 .as_millis()
1456}
1457
1458#[cfg(test)]
1459mod tests {
1460 use super::*;
1461 use std::sync::atomic::{AtomicU64, Ordering};
1462
1463 static NEXT_ROOT: AtomicU64 = AtomicU64::new(0);
1464
1465 #[test]
1466 fn windows_pipe_names_are_local_and_glass_owned() {
1467 assert!(valid_windows_pipe_name(
1468 r"\\.\pipe\glass-dev-0123456789abcdef"
1469 ));
1470 assert!(!valid_windows_pipe_name(r"\\server\pipe\glass-dev-test"));
1471 assert!(!valid_windows_pipe_name(r"\\.\pipe\other-product"));
1472 assert!(!valid_windows_pipe_name(r"\\.\pipe\glass-dev-bad/name"));
1473 }
1474
1475 fn test_context() -> DevelopmentToolContext {
1476 DevelopmentToolContext {
1477 authorization: ToolAuthorization {
1478 actor: Actor::external("daemon-concurrency-test"),
1479 allow_mutation: true,
1480 confirmed: true,
1481 },
1482 initiator: None,
1483 expected_generation: 1,
1484 expected_project_revision: 0,
1485 }
1486 }
1487
1488 #[tokio::test(flavor = "current_thread")]
1489 async fn workspace_actors_do_not_serialize_unrelated_long_operations() {
1490 let sequence = NEXT_ROOT.fetch_add(1, Ordering::Relaxed);
1491 let base = std::env::temp_dir().join(format!(
1492 "glassd-actor-concurrency-{}-{sequence}",
1493 std::process::id()
1494 ));
1495 let first_root = base.join("first");
1496 let second_root = base.join("second");
1497 std::fs::create_dir_all(&first_root).unwrap();
1498 std::fs::create_dir_all(&second_root).unwrap();
1499 for root in [&first_root, &second_root] {
1500 std::fs::write(
1501 root.join("Cargo.toml"),
1502 "[package]\nname='stress-fixture'\nversion='0.1.0'\n",
1503 )
1504 .unwrap();
1505 }
1506 let dap_adapter = second_root.join("stress_dap.py");
1507 std::fs::write(
1508 &dap_adapter,
1509 r#"import json, sys
1510while True:
1511 line = sys.stdin.buffer.readline()
1512 if not line:
1513 break
1514 if not line.lower().startswith(b'content-length:'):
1515 continue
1516 length = int(line.split(b':', 1)[1])
1517 while sys.stdin.buffer.readline() not in (b'\r\n', b'\n', b''):
1518 pass
1519 request = json.loads(sys.stdin.buffer.read(length))
1520 response = {'seq': request['seq'] + 1000, 'type': 'response', 'request_seq': request['seq'], 'command': request['command'], 'success': True, 'body': {}}
1521 body = json.dumps(response).encode()
1522 sys.stdout.buffer.write(f'Content-Length: {len(body)}\r\n\r\n'.encode() + body)
1523 sys.stdout.buffer.flush()
1524"#,
1525 )
1526 .unwrap();
1527 let store = WorkspaceTrustStore::at(base.join("trust.json"));
1528 for root in [&first_root, &second_root] {
1529 store
1530 .trust_project(&crate::WorkspaceIdentity::inspect(root).unwrap())
1531 .unwrap();
1532 }
1533 let local = tokio::task::LocalSet::new();
1534 local
1535 .run_until(async {
1536 let actor = |id: &str, root: &Path| {
1537 let workspace =
1538 DevelopmentWorkspace::open_with_store(root, store.clone()).unwrap();
1539 let summary = workspace_summary(id, &workspace);
1540 let (sender, receiver) = tokio::sync::mpsc::channel(WORKSPACE_COMMAND_CAPACITY);
1541 tokio::task::spawn_local(run_workspace_actor(id.into(), workspace, receiver));
1542 WorkspaceActorHandle { sender, summary }
1543 };
1544 let first = actor("first", &first_root);
1545 let second = actor("second", &second_root);
1546 let python = ["python3", "python"]
1547 .into_iter()
1548 .find(|program| {
1549 std::process::Command::new(program)
1550 .arg("--version")
1551 .output()
1552 .is_ok_and(|output| output.status.success())
1553 })
1554 .expect("full-suite stress requires Python for the fixture DAP adapter");
1555 workspace_tool(
1556 second.clone(),
1557 ToolCall {
1558 id: "debug-start".into(),
1559 name: "glass.debug.start".into(),
1560 arguments: serde_json::json!({
1561 "session":"stress",
1562 "command":python,
1563 "arguments":[dap_adapter],
1564 "timeoutSeconds":3
1565 }),
1566 },
1567 test_context(),
1568 )
1569 .await
1570 .unwrap();
1571 let (kernel_kind, kernel_code) = if cfg!(windows) {
1572 ("python", "import time; time.sleep(1); print('complete')")
1573 } else {
1574 ("shell", "sleep 1; echo complete")
1575 };
1576 workspace_tool(
1577 first.clone(),
1578 ToolCall {
1579 id: "shell-start".into(),
1580 name: "glass.eval.start".into(),
1581 arguments: serde_json::json!({"name":"slow","kind":kernel_kind}),
1582 },
1583 test_context(),
1584 )
1585 .await
1586 .unwrap();
1587 let slow = tokio::task::spawn_local(workspace_tool(
1588 first.clone(),
1589 ToolCall {
1590 id: "shell-slow".into(),
1591 name: "glass.eval.execute".into(),
1592 arguments: serde_json::json!({
1593 "name":"slow",
1594 "code":kernel_code,
1595 "timeoutSeconds":3
1596 }),
1597 },
1598 test_context(),
1599 ));
1600 tokio::time::sleep(Duration::from_millis(50)).await;
1601 let started = std::time::Instant::now();
1602 let (inspect, browser, lsp, debug, tests, processes) = tokio::join!(
1603 workspace_inspect(second.clone()),
1604 workspace_tool(
1605 second.clone(),
1606 ToolCall {
1607 id: "browser-state".into(),
1608 name: "glass.browser.state".into(),
1609 arguments: serde_json::json!({}),
1610 },
1611 test_context(),
1612 ),
1613 workspace_tool(
1614 second.clone(),
1615 ToolCall {
1616 id: "lsp-list".into(),
1617 name: "glass.lsp.list".into(),
1618 arguments: serde_json::json!({}),
1619 },
1620 test_context(),
1621 ),
1622 workspace_tool(
1623 second.clone(),
1624 ToolCall {
1625 id: "debug-events".into(),
1626 name: "glass.debug.events".into(),
1627 arguments: serde_json::json!({"session":"stress"}),
1628 },
1629 test_context(),
1630 ),
1631 workspace_tool(
1632 second.clone(),
1633 ToolCall {
1634 id: "test-discover".into(),
1635 name: "glass.test.discover".into(),
1636 arguments: serde_json::json!({}),
1637 },
1638 test_context(),
1639 ),
1640 workspace_tool(
1641 second.clone(),
1642 ToolCall {
1643 id: "process-list".into(),
1644 name: "glass.process.list".into(),
1645 arguments: serde_json::json!({}),
1646 },
1647 test_context(),
1648 ),
1649 );
1650 let elapsed = started.elapsed();
1651 let inspect = inspect.unwrap();
1652 assert_eq!(inspect["workspace"]["id"], "second");
1653 assert!(browser.is_ok());
1654 assert!(lsp.is_ok());
1655 assert!(debug.is_ok());
1656 assert!(tests.is_ok());
1657 assert!(processes.is_ok());
1658 assert!(
1659 elapsed < Duration::from_millis(300),
1660 "unrelated workspace inspect waited {elapsed:?}"
1661 );
1662 assert!(slow.await.unwrap().is_ok());
1663 for handle in [first, second] {
1664 let (response, received) = tokio::sync::oneshot::channel();
1665 handle
1666 .sender
1667 .send(WorkspaceCommand::Shutdown { response })
1668 .await
1669 .unwrap();
1670 received.await.unwrap();
1671 }
1672 })
1673 .await;
1674 std::fs::remove_dir_all(base).unwrap();
1675 }
1676
1677 #[tokio::test(flavor = "current_thread")]
1678 async fn workspace_event_cursors_survive_client_reconnects() {
1679 let sequence = NEXT_ROOT.fetch_add(1, Ordering::Relaxed);
1680 let root = std::env::temp_dir().join(format!(
1681 "glassd-event-cursor-{}-{sequence}",
1682 std::process::id()
1683 ));
1684 std::fs::create_dir_all(&root).unwrap();
1685 let local = tokio::task::LocalSet::new();
1686 local
1687 .run_until(async {
1688 let workspace = DevelopmentWorkspace::open(&root).unwrap();
1689 let summary = workspace_summary("events", &workspace);
1690 let (sender, receiver) = tokio::sync::mpsc::channel(WORKSPACE_COMMAND_CAPACITY);
1691 tokio::task::spawn_local(run_workspace_actor("events".into(), workspace, receiver));
1692 let first_client = WorkspaceActorHandle {
1693 sender: sender.clone(),
1694 summary: summary.clone(),
1695 };
1696 workspace_tool(
1697 first_client,
1698 ToolCall {
1699 id: "task-list".into(),
1700 name: "glass.task.list".into(),
1701 arguments: serde_json::json!({}),
1702 },
1703 test_context(),
1704 )
1705 .await
1706 .unwrap();
1707 let first = workspace_events(
1708 WorkspaceActorHandle {
1709 sender: sender.clone(),
1710 summary: summary.clone(),
1711 },
1712 0,
1713 16,
1714 )
1715 .await
1716 .unwrap();
1717 assert_eq!(first["events"][0]["kind"], "workspace.opened");
1718 assert_eq!(first["events"][1]["kind"], "task.changed");
1719 let cursor = first["newestSequence"].as_u64().unwrap();
1720
1721 let reconnected = WorkspaceActorHandle { sender, summary };
1723 workspace_tool(
1724 reconnected.clone(),
1725 ToolCall {
1726 id: "task-list-after-reconnect".into(),
1727 name: "glass.task.list".into(),
1728 arguments: serde_json::json!({}),
1729 },
1730 test_context(),
1731 )
1732 .await
1733 .unwrap();
1734 let resumed = workspace_events(reconnected, cursor, 16).await.unwrap();
1735 assert_eq!(resumed["events"].as_array().unwrap().len(), 1);
1736 assert_eq!(resumed["events"][0]["kind"], "task.changed");
1737 assert_eq!(resumed["lostBefore"], Value::Null);
1738 })
1739 .await;
1740 std::fs::remove_dir_all(root).unwrap();
1741 }
1742
1743 #[test]
1744 fn workspace_event_overflow_is_bounded_and_observable() {
1745 let mut events = VecDeque::with_capacity(WORKSPACE_EVENT_CAPACITY);
1746 let mut next = 1;
1747 let mut dropped = 0;
1748 for index in 0..=WORKSPACE_EVENT_CAPACITY {
1749 push_workspace_event(
1750 "bounded",
1751 &mut events,
1752 &mut next,
1753 &mut dropped,
1754 "workspace.changed",
1755 Some(format!("call-{index}")),
1756 true,
1757 );
1758 }
1759 let batch = workspace_event_batch(&events, next, dropped, 0, MAX_EVENT_BATCH);
1760 assert_eq!(events.len(), WORKSPACE_EVENT_CAPACITY);
1761 assert_eq!(batch["droppedEvents"], 1);
1762 assert_eq!(batch["lostBefore"], 2);
1763 assert_eq!(batch["events"].as_array().unwrap().len(), MAX_EVENT_BATCH);
1764 }
1765
1766 #[tokio::test(flavor = "current_thread")]
1767 #[cfg(unix)]
1768 async fn daemon_preserves_resources_across_client_disconnects() {
1769 let sequence = NEXT_ROOT.fetch_add(1, Ordering::Relaxed);
1770 let base =
1771 std::env::temp_dir().join(format!("glassd-test-{}-{sequence}", std::process::id()));
1772 let project = base.join("project");
1773 std::fs::create_dir_all(&project).unwrap();
1774 std::fs::write(
1775 project.join("Cargo.toml"),
1776 "[package]\nname='x'\nversion='0.1.0'\n",
1777 )
1778 .unwrap();
1779 let trust_store = WorkspaceTrustStore::at(base.join("trust.json"));
1780 trust_store
1781 .trust_project(&crate::WorkspaceIdentity::inspect(&project).unwrap())
1782 .unwrap();
1783 let socket = base.join("glassd.sock");
1784 let status = base.join("glassd.json");
1785 let local = tokio::task::LocalSet::new();
1786 local
1787 .run_until(async {
1788 let server_socket = socket.clone();
1789 let server_status = status.clone();
1790 let server_trust_store = trust_store.clone();
1791 let server = tokio::task::spawn_local(async move {
1792 serve_with_store(&server_socket, &server_status, server_trust_store)
1793 .await
1794 .unwrap()
1795 });
1796 for _ in 0..100 {
1797 if status.exists() && socket.exists() {
1798 break;
1799 }
1800 tokio::time::sleep(Duration::from_millis(10)).await;
1801 }
1802 let token = std::fs::read_to_string(token_path(&status)).unwrap();
1803 let base_request = |id: &str, operation: &str| DevelopmentDaemonRequest {
1804 id: id.into(),
1805 token: token.clone(),
1806 operation: operation.into(),
1807 workspace_id: Some("fixture".into()),
1808 root: None,
1809 call: None,
1810 expected_generation: None,
1811 expected_project_revision: None,
1812 allow_mutation: false,
1813 confirmed: false,
1814 actor: Some("test-client".into()),
1815 since: None,
1816 limit: None,
1817 };
1818 let mut open = base_request("open", "workspace.open");
1819 open.root = Some(project.clone());
1820 assert!(request(&socket, &open).await.unwrap().ok);
1821 let mut start = base_request("start", "workspace.tool");
1822 start.call = Some(ToolCall {
1823 id: "kernel-start".into(),
1824 name: "glass.eval.start".into(),
1825 arguments: serde_json::json!({"name":"durable","kind":"sql"}),
1826 });
1827 start.expected_generation = Some(1);
1828 start.expected_project_revision = Some(0);
1829 start.allow_mutation = true;
1830 start.confirmed = true;
1831 assert!(request(&socket, &start).await.unwrap().ok);
1832 let mut process_start = base_request("process-start", "workspace.tool");
1833 process_start.call = Some(ToolCall {
1834 id: "process-start".into(),
1835 name: "glass.process.start".into(),
1836 arguments: serde_json::json!({"name":"durable-process","command":"sleep 30"}),
1837 });
1838 process_start.expected_generation = Some(1);
1839 process_start.expected_project_revision = Some(0);
1840 process_start.allow_mutation = true;
1841 process_start.confirmed = true;
1842 assert!(request(&socket, &process_start).await.unwrap().ok);
1843 let pi_available = std::process::Command::new("pi")
1844 .arg("--version")
1845 .output()
1846 .is_ok();
1847 if pi_available {
1848 let mut agent_start = base_request("agent-start", "workspace.tool");
1849 agent_start.call = Some(ToolCall {
1850 id: "agent-start".into(),
1851 name: "glass.agent.spawn".into(),
1852 arguments: serde_json::json!({"spec":{
1853 "role":"durability-probe",
1854 "task":"Remain idle while the client reconnects",
1855 "dependencies":[],
1856 "model":null,
1857 "thinking":null,
1858 "worktree":null,
1859 "unrestricted":false,
1860 "maxRuntimeSeconds":60,
1861 "maxEvents":100
1862 }}),
1863 });
1864 agent_start.expected_generation = Some(1);
1865 agent_start.expected_project_revision = Some(1);
1866 agent_start.allow_mutation = true;
1867 agent_start.confirmed = true;
1868 let agent_response = request(&socket, &agent_start).await.unwrap();
1869 assert!(agent_response.ok, "{:?}", agent_response.error);
1870 }
1871 let browser_e2e = std::env::var("GLASS_E2E").as_deref() == Ok("1")
1872 && std::env::var_os("GLASS_CHROME_PATH").is_some();
1873 if browser_e2e {
1874 let port_probe = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
1875 let browser_port = port_probe.local_addr().unwrap().port();
1876 drop(port_probe);
1877 let mut browser_start = base_request("browser-start", "workspace.tool");
1878 browser_start.call = Some(ToolCall {
1879 id: "browser-start".into(),
1880 name: "glass.browser.start".into(),
1881 arguments: serde_json::json!({
1882 "port":browser_port,
1883 "incognito":true,
1884 "chromePath":std::env::var("GLASS_CHROME_PATH").unwrap()
1885 }),
1886 });
1887 browser_start.expected_generation = Some(1);
1888 browser_start.expected_project_revision = Some(1);
1889 browser_start.allow_mutation = true;
1890 browser_start.confirmed = true;
1891 let response = request(&socket, &browser_start).await.unwrap();
1892 assert!(response.ok, "{:?}", response.error);
1893 }
1894 let call = ToolCall {
1897 id: "kernel-execute".into(),
1898 name: "glass.eval.execute".into(),
1899 arguments: serde_json::json!({"name":"durable","code":"SELECT 42 AS answer"}),
1900 };
1901 let call_path = std::env::temp_dir().join(format!(
1902 "glass-pi-call-{}-{sequence}.json",
1903 std::process::id()
1904 ));
1905 write_private(&call_path, &serde_json::to_vec(&call).unwrap()).unwrap();
1906 let result = forward_resident_tool_file_with_context(
1907 &socket, &token, "fixture", &call_path, &project, true, true,
1908 )
1909 .await
1910 .unwrap();
1911 assert_eq!(result["value"][0]["answer"], 42);
1912 let inspect = request(
1915 &socket,
1916 &base_request("inspect-reconnected", "workspace.inspect"),
1917 )
1918 .await
1919 .unwrap();
1920 assert!(inspect.ok);
1921 assert!(
1922 inspect.result["processes"]
1923 .as_array()
1924 .unwrap()
1925 .iter()
1926 .any(|process| process["name"] == "durable-process")
1927 );
1928 assert!(
1929 inspect.result["kernels"]
1930 .as_array()
1931 .unwrap()
1932 .iter()
1933 .any(|kernel| kernel["name"] == "durable")
1934 );
1935 if pi_available {
1936 assert!(!inspect.result["agents"].as_array().unwrap().is_empty());
1937 }
1938 assert_eq!(inspect.result["browser"]["connected"], browser_e2e);
1939 let mut process_stop = base_request("process-stop", "workspace.tool");
1940 process_stop.call = Some(ToolCall {
1941 id: "process-stop".into(),
1942 name: "glass.process.stop".into(),
1943 arguments: serde_json::json!({"name":"durable-process"}),
1944 });
1945 process_stop.expected_generation = Some(1);
1946 process_stop.expected_project_revision = Some(1);
1947 process_stop.allow_mutation = true;
1948 process_stop.confirmed = true;
1949 assert!(request(&socket, &process_stop).await.unwrap().ok);
1950 if browser_e2e {
1951 let mut browser_stop = base_request("browser-stop", "workspace.tool");
1952 browser_stop.call = Some(ToolCall {
1953 id: "browser-stop".into(),
1954 name: "glass.browser.stop".into(),
1955 arguments: serde_json::json!({}),
1956 });
1957 browser_stop.expected_generation = Some(1);
1958 browser_stop.expected_project_revision = Some(2);
1959 browser_stop.allow_mutation = true;
1960 browser_stop.confirmed = true;
1961 assert!(request(&socket, &browser_stop).await.unwrap().ok);
1962 }
1963 server.abort();
1964 })
1965 .await;
1966 let _ = std::fs::remove_dir_all(base);
1967 }
1968
1969 #[tokio::test(flavor = "current_thread")]
1970 #[cfg(unix)]
1971 async fn daemon_reconnect_preserves_untrusted_state_and_cannot_elevate_it() {
1972 let sequence = NEXT_ROOT.fetch_add(1, Ordering::Relaxed);
1973 let base = std::env::temp_dir().join(format!(
1974 "glassd-trust-test-{}-{sequence}",
1975 std::process::id()
1976 ));
1977 let project = base.join("project");
1978 std::fs::create_dir_all(&project).unwrap();
1979 std::fs::write(
1980 project.join("glass.toml"),
1981 "[tools.hostile]\ndescription='hostile'\ncommand='echo unsafe'\n",
1982 )
1983 .unwrap();
1984 let socket = base.join("glassd.sock");
1985 let status = base.join("glassd.json");
1986 let local = tokio::task::LocalSet::new();
1987 local
1988 .run_until(async {
1989 let server_socket = socket.clone();
1990 let server_status = status.clone();
1991 let store = WorkspaceTrustStore::at(base.join("trust.json"));
1992 let server = tokio::task::spawn_local(async move {
1993 serve_with_store(&server_socket, &server_status, store)
1994 .await
1995 .unwrap()
1996 });
1997 for _ in 0..100 {
1998 if status.exists() && socket.exists() {
1999 break;
2000 }
2001 tokio::time::sleep(Duration::from_millis(10)).await;
2002 }
2003 let token = std::fs::read_to_string(token_path(&status)).unwrap();
2004 let base_request = |id: &str, operation: &str| DevelopmentDaemonRequest {
2005 id: id.into(),
2006 token: token.clone(),
2007 operation: operation.into(),
2008 workspace_id: Some("untrusted".into()),
2009 root: None,
2010 call: None,
2011 expected_generation: None,
2012 expected_project_revision: None,
2013 allow_mutation: false,
2014 confirmed: false,
2015 actor: Some("external-agent".into()),
2016 since: None,
2017 limit: None,
2018 };
2019 let mut open = base_request("open", "workspace.open");
2020 open.root = Some(project.clone());
2021 let opened = request(&socket, &open).await.unwrap();
2022 assert!(opened.ok);
2023 assert_eq!(opened.result["trust"], "untrusted");
2024
2025 let inspected = request(&socket, &base_request("inspect", "workspace.inspect"))
2028 .await
2029 .unwrap();
2030 assert!(inspected.ok);
2031 assert_eq!(inspected.result["workspace"]["trust"], "untrusted");
2032
2033 let mut tool = base_request("tool", "workspace.tool");
2034 tool.call = Some(ToolCall {
2035 id: "hostile".into(),
2036 name: "glass.custom.hostile".into(),
2037 arguments: serde_json::json!({}),
2038 });
2039 tool.expected_generation = Some(1);
2040 tool.expected_project_revision = Some(0);
2041 tool.allow_mutation = true;
2042 tool.confirmed = true;
2043 let denied = request(&socket, &tool).await.unwrap();
2044 assert!(!denied.ok);
2045 assert!(denied.error.unwrap().contains("trust"));
2046 server.abort();
2047 })
2048 .await;
2049 let _ = std::fs::remove_dir_all(base);
2050 }
2051
2052 #[test]
2053 fn daemon_identifiers_and_status_quotas_fail_closed() {
2054 assert!(validate_identifier("workspace-1", "workspace").is_ok());
2055 assert!(validate_identifier("../escape", "workspace").is_err());
2056 }
2057}