1use crate::{DevelopmentToolContext, DevelopmentWorkspace, ResidentAgentBroker};
4use glass_browser::cli::args::DaemonCommand;
5use glass_browser::development::{Actor, ToolAuthorization, ToolCall};
6use serde::{Deserialize, Serialize};
7use serde_json::Value;
8use std::collections::BTreeMap;
9use std::path::{Path, PathBuf};
10use std::time::{Duration, SystemTime, UNIX_EPOCH};
11use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
12
13const PROTOCOL_VERSION: u32 = 1;
14const MAX_REQUEST_BYTES: usize = 1024 * 1024;
15const MAX_RESPONSE_BYTES: usize = 1024 * 1024;
16const MAX_WORKSPACES: usize = 8;
17const MAX_CLIENTS: usize = 16;
18
19#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(rename_all = "camelCase")]
21pub struct DevelopmentDaemonStatus {
22 pub protocol_version: u32,
23 pub state: String,
24 pub pid: u32,
25 pub socket: PathBuf,
26 pub status_path: PathBuf,
27 pub token_path: PathBuf,
28 pub started_at_ms: u128,
29 pub workspace_count: usize,
30 pub client_count: usize,
31}
32
33#[derive(Debug, Clone, Serialize, Deserialize)]
34#[serde(rename_all = "camelCase")]
35pub struct DevelopmentDaemonRequest {
36 pub id: String,
37 pub token: String,
38 pub operation: String,
39 pub workspace_id: Option<String>,
40 pub root: Option<PathBuf>,
41 pub call: Option<ToolCall>,
42 pub expected_generation: Option<u64>,
43 pub expected_project_revision: Option<u64>,
44 #[serde(default)]
45 pub allow_mutation: bool,
46 #[serde(default)]
47 pub confirmed: bool,
48 pub actor: Option<String>,
49}
50
51#[derive(Debug, Clone, Serialize, Deserialize)]
52#[serde(rename_all = "camelCase")]
53pub struct DevelopmentDaemonResponse {
54 pub id: String,
55 pub ok: bool,
56 pub result: Value,
57 pub error: Option<String>,
58}
59
60pub async fn dispatch(action: &DaemonCommand) -> Result<(), Box<dyn std::error::Error>> {
61 match action {
62 DaemonCommand::Start { socket, status } => {
63 println!(
64 "{}",
65 serde_json::to_string_pretty(&start(socket.as_deref(), status.as_deref()).await?)?
66 );
67 }
68 DaemonCommand::Status { socket, status } | DaemonCommand::Doctor { socket, status } => {
69 println!(
70 "{}",
71 serde_json::to_string_pretty(&read_status_checked(
72 socket.as_deref(),
73 status.as_deref()
74 )?)?
75 );
76 }
77 DaemonCommand::Stop { socket, status } => {
78 stop(socket.as_deref(), status.as_deref())?;
79 println!("{{\"status\":\"stopped\"}}");
80 }
81 DaemonCommand::Logs { status } => {
82 let (_, default_status) = default_paths();
83 let status = status.as_deref().unwrap_or(&default_status);
84 print!("{}", bounded_log(status)?);
85 }
86 DaemonCommand::AcknowledgeRecovery { .. } => {
87 println!("{{\"status\":\"no-recovery-required\"}}");
88 }
89 DaemonCommand::Serve { socket, status } => serve(socket, status).await?,
90 }
91 Ok(())
92}
93
94pub fn default_paths() -> (PathBuf, PathBuf) {
95 let base = std::env::var_os("XDG_RUNTIME_DIR")
96 .map(PathBuf::from)
97 .or_else(|| std::env::var_os("XDG_DATA_HOME").map(PathBuf::from))
98 .unwrap_or_else(|| std::env::temp_dir().join(format!("glass-{}", effective_uid())));
99 let root = base.join("glass-dev");
100 (root.join("glassd.sock"), root.join("glassd.json"))
101}
102
103pub async fn start(
104 socket: Option<&Path>,
105 status_path: Option<&Path>,
106) -> Result<DevelopmentDaemonStatus, Box<dyn std::error::Error>> {
107 #[cfg(not(unix))]
108 {
109 let _ = (socket, status_path);
110 return Err("the durable development daemon currently requires Unix local sockets".into());
111 }
112 #[cfg(unix)]
113 {
114 let (default_socket, default_status) = default_paths();
115 let socket = socket.unwrap_or(&default_socket);
116 let status_path = status_path.unwrap_or(&default_status);
117 if let Ok(existing) = read_status(status_path)
118 && process_alive(existing.pid)
119 {
120 return Err(
121 format!("development daemon is already running as {}", existing.pid).into(),
122 );
123 }
124 remove_socket_if_safe(socket)?;
125 if status_path.exists() {
126 std::fs::remove_file(status_path)?;
127 }
128 std::fs::create_dir_all(socket.parent().unwrap_or_else(|| Path::new(".")))?;
129 std::fs::create_dir_all(status_path.parent().unwrap_or_else(|| Path::new(".")))?;
130 let log = log_path(status_path);
131 let stdout = std::fs::OpenOptions::new()
132 .create(true)
133 .append(true)
134 .open(&log)?;
135 let stderr = stdout.try_clone()?;
136 std::process::Command::new(std::env::current_exe()?)
137 .args(["daemon", "serve"])
138 .arg("--socket")
139 .arg(socket)
140 .arg("--status")
141 .arg(status_path)
142 .stdin(std::process::Stdio::null())
143 .stdout(std::process::Stdio::from(stdout))
144 .stderr(std::process::Stdio::from(stderr))
145 .spawn()?;
146 let deadline = std::time::Instant::now() + Duration::from_secs(3);
147 loop {
148 if let Ok(status) = read_status(status_path)
149 && process_alive(status.pid)
150 && status.socket == socket
151 {
152 return Ok(status);
153 }
154 if std::time::Instant::now() >= deadline {
155 return Err("development daemon did not become ready within three seconds".into());
156 }
157 tokio::time::sleep(Duration::from_millis(25)).await;
158 }
159 }
160}
161
162pub fn read_status_checked(
163 socket: Option<&Path>,
164 status_path: Option<&Path>,
165) -> Result<DevelopmentDaemonStatus, Box<dyn std::error::Error>> {
166 let (default_socket, default_status) = default_paths();
167 let expected_socket = socket.unwrap_or(&default_socket);
168 let status_path = status_path.unwrap_or(&default_status);
169 let mut status = read_status(status_path)?;
170 validate_status(&status, status_path)?;
171 if status.socket != expected_socket {
172 return Err("daemon status socket does not match the requested socket".into());
173 }
174 if !process_alive(status.pid) {
175 status.state = "stopped".into();
176 }
177 Ok(status)
178}
179
180pub fn stop(
181 socket: Option<&Path>,
182 status_path: Option<&Path>,
183) -> Result<(), Box<dyn std::error::Error>> {
184 #[cfg(not(unix))]
185 {
186 let _ = (socket, status_path);
187 return Err("the durable development daemon currently requires Unix".into());
188 }
189 #[cfg(unix)]
190 {
191 let status = read_status_checked(socket, status_path)?;
192 if status.pid == std::process::id() {
193 return Err("refusing to stop the calling process".into());
194 }
195 let result = unsafe { libc::kill(status.pid as i32, libc::SIGTERM) };
196 if result != 0 {
197 return Err(std::io::Error::last_os_error().into());
198 }
199 Ok(())
200 }
201}
202
203pub async fn serve(socket: &Path, status_path: &Path) -> Result<(), Box<dyn std::error::Error>> {
204 #[cfg(not(unix))]
205 {
206 let _ = (socket, status_path);
207 return Err("the durable development daemon currently requires Unix".into());
208 }
209 #[cfg(unix)]
210 {
211 use std::os::unix::fs::PermissionsExt;
212 use tokio::net::UnixListener;
213 use tokio::signal::unix::{SignalKind, signal};
214
215 remove_socket_if_safe(socket)?;
216 std::fs::create_dir_all(socket.parent().unwrap_or_else(|| Path::new(".")))?;
217 std::fs::create_dir_all(status_path.parent().unwrap_or_else(|| Path::new(".")))?;
218 let listener = UnixListener::bind(socket)?;
219 std::fs::set_permissions(socket, std::fs::Permissions::from_mode(0o600))?;
220 let token_path = token_path(status_path);
221 let token = create_token()?;
222 write_private(&token_path, token.as_bytes())?;
223 let status = DevelopmentDaemonStatus {
224 protocol_version: PROTOCOL_VERSION,
225 state: "running".into(),
226 pid: std::process::id(),
227 socket: socket.to_path_buf(),
228 status_path: status_path.to_path_buf(),
229 token_path: token_path.clone(),
230 started_at_ms: now_ms(),
231 workspace_count: 0,
232 client_count: 0,
233 };
234 write_status(status_path, &status)?;
235 let workspaces = std::rc::Rc::new(tokio::sync::Mutex::new(BTreeMap::<
236 String,
237 DevelopmentWorkspace,
238 >::new()));
239 let clients = std::rc::Rc::new(std::cell::Cell::new(0_usize));
240 let local = tokio::task::LocalSet::new();
241 let mut terminate = signal(SignalKind::terminate())?;
242 local
243 .run_until(async {
244 loop {
245 let (stream, _) = tokio::select! {
246 accepted = listener.accept() => accepted?,
247 _ = terminate.recv() => break,
248 };
249 authorize_local_peer(&stream)?;
250 if clients.get() >= MAX_CLIENTS {
251 continue;
252 }
253 clients.set(clients.get() + 1);
254 update_counts(status_path, workspaces.lock().await.len(), clients.get())?;
255 let workspaces = std::rc::Rc::clone(&workspaces);
256 let clients = std::rc::Rc::clone(&clients);
257 let token = token.clone();
258 let status_path = status_path.to_path_buf();
259 let socket = socket.to_path_buf();
260 tokio::task::spawn_local(async move {
261 if let Err(error) =
262 handle_client(stream, &token, &socket, &workspaces).await
263 {
264 tracing::warn!(%error, "development daemon client failed");
265 }
266 clients.set(clients.get().saturating_sub(1));
267 let workspace_count = workspaces.lock().await.len();
268 let _ = update_counts(&status_path, workspace_count, clients.get());
269 });
270 }
271 Ok::<(), Box<dyn std::error::Error>>(())
272 })
273 .await?;
274 let _ = std::fs::remove_file(status_path);
275 let _ = std::fs::remove_file(token_path);
276 remove_socket_if_safe(socket)?;
277 Ok(())
278 }
279}
280
281#[cfg(unix)]
282async fn handle_client(
283 stream: tokio::net::UnixStream,
284 token: &str,
285 socket: &Path,
286 workspaces: &std::rc::Rc<tokio::sync::Mutex<BTreeMap<String, DevelopmentWorkspace>>>,
287) -> Result<(), Box<dyn std::error::Error>> {
288 let (read, mut write) = stream.into_split();
289 let mut lines = BufReader::new(read).lines();
290 while let Some(line) = lines.next_line().await? {
291 let response = if line.len() > MAX_REQUEST_BYTES {
292 DevelopmentDaemonResponse {
293 id: "oversized".into(),
294 ok: false,
295 result: Value::Null,
296 error: Some("daemon request exceeds the size limit".into()),
297 }
298 } else {
299 match serde_json::from_str::<DevelopmentDaemonRequest>(&line) {
300 Ok(request) => execute_request(request, token, socket, workspaces).await,
301 Err(error) => DevelopmentDaemonResponse {
302 id: "invalid".into(),
303 ok: false,
304 result: Value::Null,
305 error: Some(format!("invalid daemon request: {error}")),
306 },
307 }
308 };
309 let encoded = serde_json::to_vec(&response)?;
310 if encoded.len() > MAX_RESPONSE_BYTES {
311 return Err("daemon response exceeds the size limit".into());
312 }
313 write.write_all(&encoded).await?;
314 write.write_all(b"\n").await?;
315 write.flush().await?;
316 }
317 Ok(())
318}
319
320async fn execute_request(
321 request: DevelopmentDaemonRequest,
322 token: &str,
323 socket: &Path,
324 workspaces: &tokio::sync::Mutex<BTreeMap<String, DevelopmentWorkspace>>,
325) -> DevelopmentDaemonResponse {
326 let id = request.id.clone();
327 let result = async {
328 validate_request(&request, token)?;
329 match request.operation.as_str() {
330 "ping" => Ok(serde_json::json!({"protocolVersion":PROTOCOL_VERSION})),
331 "workspace.open" => {
332 let workspace_id = required_workspace_id(&request)?;
333 let root = request
334 .root
335 .as_deref()
336 .ok_or("workspace.open requires root")?;
337 let mut state = workspaces.lock().await;
338 if state.contains_key(workspace_id) {
339 return Err("workspace identity is already open".into());
340 }
341 if state.len() >= MAX_WORKSPACES {
342 return Err("daemon workspace quota reached".into());
343 }
344 let mut workspace =
345 DevelopmentWorkspace::open(root).map_err(|error| error.to_string())?;
346 workspace
347 .agents()
348 .set_resident_broker(ResidentAgentBroker {
349 socket: socket.to_path_buf(),
350 token: token.to_string(),
351 workspace_id: workspace_id.to_string(),
352 })
353 .map_err(|error| error.to_string())?;
354 let result = workspace_summary(workspace_id, &workspace);
355 state.insert(workspace_id.into(), workspace);
356 Ok(result)
357 }
358 "workspace.inspect" => {
359 let workspace_id = required_workspace_id(&request)?;
360 let mut state = workspaces.lock().await;
361 let workspace = state
362 .get_mut(workspace_id)
363 .ok_or("unknown durable workspace")?;
364 let agents = workspace
365 .agents()
366 .list()
367 .map_err(|error| error.to_string())?;
368 let processes = workspace
369 .project_mut()
370 .processes()
371 .list_checked()
372 .map_err(|error| error.to_string())?;
373 Ok(serde_json::json!({
374 "workspace":workspace_summary(workspace_id, workspace),
375 "processes":processes,
376 "agents":agents,
377 "kernels":workspace.kernels().snapshots().collect::<Vec<_>>(),
378 "debuggers":workspace.debugger_names().collect::<Vec<_>>(),
379 "browser":workspace.browser().state().map_err(|error| error.to_string())?
380 }))
381 }
382 "workspace.tool" => {
383 let workspace_id = required_workspace_id(&request)?;
384 let call = request
385 .call
386 .as_ref()
387 .ok_or("workspace.tool requires call")?;
388 let mut state = workspaces.lock().await;
389 let workspace = state
390 .get_mut(workspace_id)
391 .ok_or("unknown durable workspace")?;
392 let actor = request
393 .actor
394 .as_deref()
395 .map(Actor::external)
396 .unwrap_or_else(Actor::local);
397 let context = DevelopmentToolContext {
398 authorization: ToolAuthorization {
399 actor,
400 allow_mutation: request.allow_mutation,
401 confirmed: request.confirmed,
402 },
403 expected_generation: request
404 .expected_generation
405 .ok_or("workspace.tool requires expectedGeneration")?,
406 expected_project_revision: request
407 .expected_project_revision
408 .ok_or("workspace.tool requires expectedProjectRevision")?,
409 };
410 workspace
411 .execute_tool(call, &context)
412 .map_err(|error| error.to_string())
413 }
414 "workspace.close" => {
415 let workspace_id = required_workspace_id(&request)?;
416 let removed = workspaces.lock().await.remove(workspace_id).is_some();
417 Ok(serde_json::json!({"closed":removed}))
418 }
419 _ => Err("unknown daemon operation".into()),
420 }
421 }
422 .await;
423 match result {
424 Ok(result) => DevelopmentDaemonResponse {
425 id,
426 ok: true,
427 result,
428 error: None,
429 },
430 Err(error) => DevelopmentDaemonResponse {
431 id,
432 ok: false,
433 result: Value::Null,
434 error: Some(error),
435 },
436 }
437}
438
439#[cfg(unix)]
440pub async fn request(
441 socket: &Path,
442 request: &DevelopmentDaemonRequest,
443) -> Result<DevelopmentDaemonResponse, Box<dyn std::error::Error>> {
444 let stream = tokio::net::UnixStream::connect(socket).await?;
445 let (read, mut write) = stream.into_split();
446 let encoded = serde_json::to_vec(request)?;
447 if encoded.len() > MAX_REQUEST_BYTES {
448 return Err("daemon request exceeds the size limit".into());
449 }
450 write.write_all(&encoded).await?;
451 write.write_all(b"\n").await?;
452 write.flush().await?;
453 let mut line = String::new();
454 BufReader::new(read).read_line(&mut line).await?;
455 Ok(serde_json::from_str(&line)?)
456}
457
458#[cfg(not(unix))]
459pub async fn request(
460 _socket: &Path,
461 _request: &DevelopmentDaemonRequest,
462) -> Result<DevelopmentDaemonResponse, Box<dyn std::error::Error>> {
463 Err("the local development daemon requires Unix-domain sockets on this platform".into())
464}
465
466pub async fn forward_resident_tool_file(
467 path: &Path,
468 root: &Path,
469 allow_mutation: bool,
470 confirmed: bool,
471) -> Result<Value, Box<dyn std::error::Error>> {
472 let socket = PathBuf::from(
473 std::env::var_os("GLASS_DEV_DAEMON_SOCKET")
474 .ok_or("resident Pi broker socket is missing")?,
475 );
476 let token = std::env::var("GLASS_DEV_DAEMON_TOKEN")
477 .map_err(|_| "resident Pi broker token is missing")?;
478 let workspace_id = std::env::var("GLASS_DEV_DAEMON_WORKSPACE")
479 .map_err(|_| "resident Pi broker workspace is missing")?;
480 forward_resident_tool_file_with_context(
481 &socket,
482 &token,
483 &workspace_id,
484 path,
485 root,
486 allow_mutation,
487 confirmed,
488 )
489 .await
490}
491
492async fn forward_resident_tool_file_with_context(
493 socket: &Path,
494 token: &str,
495 workspace_id: &str,
496 path: &Path,
497 root: &Path,
498 allow_mutation: bool,
499 confirmed: bool,
500) -> Result<Value, Box<dyn std::error::Error>> {
501 let call = read_private_tool_call(path)?;
502 let inspect = request(
503 socket,
504 &DevelopmentDaemonRequest {
505 id: format!("inspect-{}", call.id),
506 token: token.to_string(),
507 operation: "workspace.inspect".into(),
508 workspace_id: Some(workspace_id.to_string()),
509 root: None,
510 call: None,
511 expected_generation: None,
512 expected_project_revision: None,
513 allow_mutation: false,
514 confirmed: false,
515 actor: Some("pi".into()),
516 },
517 )
518 .await?;
519 if !inspect.ok {
520 return Err(inspect
521 .error
522 .unwrap_or_else(|| "workspace inspect failed".into())
523 .into());
524 }
525 let expected_root = std::fs::canonicalize(root)?;
526 let observed_root = inspect
527 .result
528 .pointer("/workspace/root")
529 .and_then(Value::as_str);
530 if observed_root != expected_root.to_str() {
531 return Err("resident Pi broker root does not match the durable workspace".into());
532 }
533 let generation = inspect
534 .result
535 .pointer("/workspace/generation")
536 .and_then(Value::as_u64)
537 .ok_or("durable workspace generation is missing")?;
538 let revision = inspect
539 .result
540 .pointer("/workspace/projectRevision")
541 .and_then(Value::as_u64)
542 .ok_or("durable workspace revision is missing")?;
543 let response = request(
544 socket,
545 &DevelopmentDaemonRequest {
546 id: format!("tool-{}", call.id),
547 token: token.to_string(),
548 operation: "workspace.tool".into(),
549 workspace_id: Some(workspace_id.to_string()),
550 root: None,
551 call: Some(call),
552 expected_generation: Some(generation),
553 expected_project_revision: Some(revision),
554 allow_mutation,
555 confirmed,
556 actor: Some("pi".into()),
557 },
558 )
559 .await?;
560 if response.ok {
561 Ok(response.result)
562 } else {
563 Err(response
564 .error
565 .unwrap_or_else(|| "resident tool call failed".into())
566 .into())
567 }
568}
569
570pub(crate) fn read_private_tool_call(path: &Path) -> Result<ToolCall, Box<dyn std::error::Error>> {
571 use std::io::Read;
572 const MAX_CALL_BYTES: u64 = 256 * 1024;
573 let canonical = path.canonicalize()?;
574 let temporary_root = std::env::temp_dir().canonicalize()?;
575 if canonical.parent() != Some(temporary_root.as_path())
576 || !canonical
577 .file_name()
578 .and_then(|name| name.to_str())
579 .is_some_and(|name| name.starts_with("glass-pi-call-") && name.ends_with(".json"))
580 {
581 return Err("Pi broker requests must use a private Glass temporary file".into());
582 }
583 let mut options = std::fs::OpenOptions::new();
584 options.read(true);
585 #[cfg(unix)]
586 {
587 use std::os::unix::fs::OpenOptionsExt;
588 options.custom_flags(libc::O_NOFOLLOW);
589 }
590 let file = options.open(&canonical)?;
591 let metadata = file.metadata()?;
592 if !metadata.is_file() || metadata.len() > MAX_CALL_BYTES {
593 return Err("invalid Pi broker request file".into());
594 }
595 #[cfg(unix)]
596 {
597 use std::os::unix::fs::{MetadataExt, PermissionsExt};
598 if metadata.uid() != unsafe { libc::geteuid() }
599 || metadata.permissions().mode() & 0o077 != 0
600 {
601 return Err("Pi broker request must be owned by this user with mode 0600".into());
602 }
603 }
604 let mut encoded = Vec::with_capacity(metadata.len() as usize);
605 file.take(MAX_CALL_BYTES + 1).read_to_end(&mut encoded)?;
606 std::fs::remove_file(&canonical)?;
607 if encoded.len() as u64 > MAX_CALL_BYTES {
608 return Err("Pi broker request exceeds the size limit".into());
609 }
610 Ok(serde_json::from_slice(&encoded)?)
611}
612
613fn workspace_summary(id: &str, workspace: &DevelopmentWorkspace) -> Value {
614 serde_json::json!({
615 "id":id,
616 "root":workspace.root(),
617 "generation":workspace.generation(),
618 "projectRevision":workspace.project().revision()
619 })
620}
621
622fn validate_request(request: &DevelopmentDaemonRequest, token: &str) -> Result<(), String> {
623 if request.token.as_bytes() != token.as_bytes() {
624 return Err("invalid daemon authentication token".into());
625 }
626 validate_identifier(&request.id, "request")?;
627 if request.operation.is_empty()
628 || request.operation.len() > 128
629 || request.operation.chars().any(char::is_control)
630 {
631 return Err("invalid daemon operation".into());
632 }
633 Ok(())
634}
635
636fn required_workspace_id(request: &DevelopmentDaemonRequest) -> Result<&str, String> {
637 let id = request
638 .workspace_id
639 .as_deref()
640 .ok_or("daemon request requires workspaceId")?;
641 validate_identifier(id, "workspace")?;
642 Ok(id)
643}
644
645fn validate_identifier(value: &str, description: &str) -> Result<(), String> {
646 if value.is_empty()
647 || value.len() > 128
648 || !value
649 .chars()
650 .all(|character| character.is_ascii_alphanumeric() || "-_.".contains(character))
651 {
652 return Err(format!("invalid {description} identifier"));
653 }
654 Ok(())
655}
656
657fn read_status(path: &Path) -> Result<DevelopmentDaemonStatus, Box<dyn std::error::Error>> {
658 let bytes = std::fs::read(path)?;
659 if bytes.len() > 64 * 1024 {
660 return Err("daemon status exceeds the size limit".into());
661 }
662 Ok(serde_json::from_slice(&bytes)?)
663}
664
665fn validate_status(
666 status: &DevelopmentDaemonStatus,
667 path: &Path,
668) -> Result<(), Box<dyn std::error::Error>> {
669 if status.protocol_version != PROTOCOL_VERSION || status.status_path != path {
670 return Err("invalid development daemon status contract".into());
671 }
672 if status.workspace_count > MAX_WORKSPACES || status.client_count > MAX_CLIENTS {
673 return Err("daemon status exceeds resource quotas".into());
674 }
675 Ok(())
676}
677
678fn write_status(
679 path: &Path,
680 status: &DevelopmentDaemonStatus,
681) -> Result<(), Box<dyn std::error::Error>> {
682 let encoded = serde_json::to_vec_pretty(status)?;
683 write_private(path, &encoded)
684}
685
686fn update_counts(
687 status_path: &Path,
688 workspace_count: usize,
689 client_count: usize,
690) -> Result<(), Box<dyn std::error::Error>> {
691 let mut status = read_status(status_path)?;
692 status.workspace_count = workspace_count;
693 status.client_count = client_count;
694 write_status(status_path, &status)
695}
696
697fn write_private(path: &Path, bytes: &[u8]) -> Result<(), Box<dyn std::error::Error>> {
698 use std::io::Write;
699 #[cfg(unix)]
700 use std::os::unix::fs::OpenOptionsExt;
701 let temporary = path.with_extension(format!("tmp-{}", std::process::id()));
702 let mut options = std::fs::OpenOptions::new();
703 options.create_new(true).write(true);
704 #[cfg(unix)]
705 options.mode(0o600);
706 let mut file = options.open(&temporary)?;
707 file.write_all(bytes)?;
708 file.sync_all()?;
709 std::fs::rename(temporary, path)?;
710 Ok(())
711}
712
713fn create_token() -> Result<String, Box<dyn std::error::Error>> {
714 use std::io::Read;
715 let mut bytes = [0_u8; 32];
716 std::fs::File::open("/dev/urandom")?.read_exact(&mut bytes)?;
717 Ok(bytes.iter().map(|byte| format!("{byte:02x}")).collect())
718}
719
720fn token_path(status: &Path) -> PathBuf {
721 status.with_extension("token")
722}
723
724fn log_path(status: &Path) -> PathBuf {
725 status.with_extension("log")
726}
727
728fn bounded_log(status: &Path) -> Result<String, Box<dyn std::error::Error>> {
729 use std::io::{Read, Seek, SeekFrom};
730 let mut file = std::fs::File::open(log_path(status))?;
731 let length = file.metadata()?.len();
732 let start = length.saturating_sub(64 * 1024);
733 file.seek(SeekFrom::Start(start))?;
734 let mut output = String::new();
735 file.read_to_string(&mut output)?;
736 Ok(output)
737}
738
739#[cfg(unix)]
740fn authorize_local_peer(stream: &tokio::net::UnixStream) -> Result<(), Box<dyn std::error::Error>> {
741 #[cfg(target_os = "linux")]
742 {
743 use std::os::fd::AsRawFd;
744 let mut credentials = libc::ucred {
745 pid: 0,
746 uid: 0,
747 gid: 0,
748 };
749 let mut length = std::mem::size_of::<libc::ucred>() as libc::socklen_t;
750 let result = unsafe {
751 libc::getsockopt(
752 stream.as_raw_fd(),
753 libc::SOL_SOCKET,
754 libc::SO_PEERCRED,
755 (&mut credentials as *mut libc::ucred).cast(),
756 &mut length,
757 )
758 };
759 if result != 0 || credentials.uid != unsafe { libc::geteuid() } {
760 return Err("daemon rejected a non-local-user peer".into());
761 }
762 }
763 Ok(())
764}
765
766#[cfg(unix)]
767fn remove_socket_if_safe(path: &Path) -> Result<(), Box<dyn std::error::Error>> {
768 use std::os::unix::fs::FileTypeExt;
769 match std::fs::symlink_metadata(path) {
770 Ok(metadata) if metadata.file_type().is_socket() => std::fs::remove_file(path)?,
771 Ok(_) => return Err(format!("refusing to replace non-socket {}", path.display()).into()),
772 Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
773 Err(error) => return Err(error.into()),
774 }
775 Ok(())
776}
777
778#[cfg(not(unix))]
779fn remove_socket_if_safe(_path: &Path) -> Result<(), Box<dyn std::error::Error>> {
780 Ok(())
781}
782
783fn process_alive(pid: u32) -> bool {
784 #[cfg(unix)]
785 {
786 unsafe { libc::kill(pid as i32, 0) == 0 }
787 }
788 #[cfg(not(unix))]
789 {
790 let _ = pid;
791 false
792 }
793}
794
795fn effective_uid() -> u32 {
796 #[cfg(unix)]
797 {
798 unsafe { libc::geteuid() }
799 }
800 #[cfg(not(unix))]
801 {
802 0
803 }
804}
805
806fn now_ms() -> u128 {
807 SystemTime::now()
808 .duration_since(UNIX_EPOCH)
809 .unwrap_or_default()
810 .as_millis()
811}
812
813#[cfg(test)]
814mod tests {
815 use super::*;
816 use std::sync::atomic::{AtomicU64, Ordering};
817
818 static NEXT_ROOT: AtomicU64 = AtomicU64::new(0);
819
820 #[tokio::test(flavor = "current_thread")]
821 #[cfg(unix)]
822 async fn daemon_preserves_resources_across_client_disconnects() {
823 let sequence = NEXT_ROOT.fetch_add(1, Ordering::Relaxed);
824 let base =
825 std::env::temp_dir().join(format!("glassd-test-{}-{sequence}", std::process::id()));
826 let project = base.join("project");
827 std::fs::create_dir_all(&project).unwrap();
828 std::fs::write(
829 project.join("Cargo.toml"),
830 "[package]\nname='x'\nversion='0.1.0'\n",
831 )
832 .unwrap();
833 let socket = base.join("glassd.sock");
834 let status = base.join("glassd.json");
835 let local = tokio::task::LocalSet::new();
836 local
837 .run_until(async {
838 let server_socket = socket.clone();
839 let server_status = status.clone();
840 let server = tokio::task::spawn_local(async move {
841 serve(&server_socket, &server_status).await.unwrap()
842 });
843 for _ in 0..100 {
844 if status.exists() && socket.exists() {
845 break;
846 }
847 tokio::time::sleep(Duration::from_millis(10)).await;
848 }
849 let token = std::fs::read_to_string(token_path(&status)).unwrap();
850 let base_request = |id: &str, operation: &str| DevelopmentDaemonRequest {
851 id: id.into(),
852 token: token.clone(),
853 operation: operation.into(),
854 workspace_id: Some("fixture".into()),
855 root: None,
856 call: None,
857 expected_generation: None,
858 expected_project_revision: None,
859 allow_mutation: false,
860 confirmed: false,
861 actor: Some("test-client".into()),
862 };
863 let mut open = base_request("open", "workspace.open");
864 open.root = Some(project.clone());
865 assert!(request(&socket, &open).await.unwrap().ok);
866 let mut start = base_request("start", "workspace.tool");
867 start.call = Some(ToolCall {
868 id: "kernel-start".into(),
869 name: "glass.eval.start".into(),
870 arguments: serde_json::json!({"name":"durable","kind":"sql"}),
871 });
872 start.expected_generation = Some(1);
873 start.expected_project_revision = Some(0);
874 start.allow_mutation = true;
875 start.confirmed = true;
876 assert!(request(&socket, &start).await.unwrap().ok);
877 let mut process_start = base_request("process-start", "workspace.tool");
878 process_start.call = Some(ToolCall {
879 id: "process-start".into(),
880 name: "glass.process.start".into(),
881 arguments: serde_json::json!({"name":"durable-process","command":"sleep 30"}),
882 });
883 process_start.expected_generation = Some(1);
884 process_start.expected_project_revision = Some(0);
885 process_start.allow_mutation = true;
886 process_start.confirmed = true;
887 assert!(request(&socket, &process_start).await.unwrap().ok);
888 let pi_available = std::process::Command::new("pi")
889 .arg("--version")
890 .output()
891 .is_ok();
892 if pi_available {
893 let mut agent_start = base_request("agent-start", "workspace.tool");
894 agent_start.call = Some(ToolCall {
895 id: "agent-start".into(),
896 name: "glass.agent.spawn".into(),
897 arguments: serde_json::json!({"spec":{
898 "role":"durability-probe",
899 "task":"Remain idle while the client reconnects",
900 "dependencies":[],
901 "model":null,
902 "thinking":null,
903 "worktree":null,
904 "unrestricted":false,
905 "maxRuntimeSeconds":60,
906 "maxEvents":100
907 }}),
908 });
909 agent_start.expected_generation = Some(1);
910 agent_start.expected_project_revision = Some(1);
911 agent_start.allow_mutation = true;
912 agent_start.confirmed = true;
913 let agent_response = request(&socket, &agent_start).await.unwrap();
914 assert!(agent_response.ok, "{:?}", agent_response.error);
915 }
916 let browser_e2e = std::env::var("GLASS_E2E").as_deref() == Ok("1")
917 && std::env::var_os("GLASS_CHROME_PATH").is_some();
918 if browser_e2e {
919 let port_probe = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
920 let browser_port = port_probe.local_addr().unwrap().port();
921 drop(port_probe);
922 let mut browser_start = base_request("browser-start", "workspace.tool");
923 browser_start.call = Some(ToolCall {
924 id: "browser-start".into(),
925 name: "glass.browser.start".into(),
926 arguments: serde_json::json!({
927 "port":browser_port,
928 "incognito":true,
929 "chromePath":std::env::var("GLASS_CHROME_PATH").unwrap()
930 }),
931 });
932 browser_start.expected_generation = Some(1);
933 browser_start.expected_project_revision = Some(1);
934 browser_start.allow_mutation = true;
935 browser_start.confirmed = true;
936 let response = request(&socket, &browser_start).await.unwrap();
937 assert!(response.ok, "{:?}", response.error);
938 }
939 let call = ToolCall {
942 id: "kernel-execute".into(),
943 name: "glass.eval.execute".into(),
944 arguments: serde_json::json!({"name":"durable","code":"SELECT 42 AS answer"}),
945 };
946 let call_path = std::env::temp_dir().join(format!(
947 "glass-pi-call-{}-{sequence}.json",
948 std::process::id()
949 ));
950 write_private(&call_path, &serde_json::to_vec(&call).unwrap()).unwrap();
951 let result = forward_resident_tool_file_with_context(
952 &socket, &token, "fixture", &call_path, &project, true, true,
953 )
954 .await
955 .unwrap();
956 assert_eq!(result["value"][0]["answer"], 42);
957 let inspect = request(
960 &socket,
961 &base_request("inspect-reconnected", "workspace.inspect"),
962 )
963 .await
964 .unwrap();
965 assert!(inspect.ok);
966 assert!(
967 inspect.result["processes"]
968 .as_array()
969 .unwrap()
970 .iter()
971 .any(|process| process["name"] == "durable-process")
972 );
973 assert!(
974 inspect.result["kernels"]
975 .as_array()
976 .unwrap()
977 .iter()
978 .any(|kernel| kernel["name"] == "durable")
979 );
980 if pi_available {
981 assert!(!inspect.result["agents"].as_array().unwrap().is_empty());
982 }
983 assert_eq!(inspect.result["browser"]["connected"], browser_e2e);
984 let mut process_stop = base_request("process-stop", "workspace.tool");
985 process_stop.call = Some(ToolCall {
986 id: "process-stop".into(),
987 name: "glass.process.stop".into(),
988 arguments: serde_json::json!({"name":"durable-process"}),
989 });
990 process_stop.expected_generation = Some(1);
991 process_stop.expected_project_revision = Some(1);
992 process_stop.allow_mutation = true;
993 process_stop.confirmed = true;
994 assert!(request(&socket, &process_stop).await.unwrap().ok);
995 if browser_e2e {
996 let mut browser_stop = base_request("browser-stop", "workspace.tool");
997 browser_stop.call = Some(ToolCall {
998 id: "browser-stop".into(),
999 name: "glass.browser.stop".into(),
1000 arguments: serde_json::json!({}),
1001 });
1002 browser_stop.expected_generation = Some(1);
1003 browser_stop.expected_project_revision = Some(2);
1004 browser_stop.allow_mutation = true;
1005 browser_stop.confirmed = true;
1006 assert!(request(&socket, &browser_stop).await.unwrap().ok);
1007 }
1008 server.abort();
1009 })
1010 .await;
1011 let _ = std::fs::remove_dir_all(base);
1012 }
1013
1014 #[test]
1015 fn daemon_identifiers_and_status_quotas_fail_closed() {
1016 assert!(validate_identifier("workspace-1", "workspace").is_ok());
1017 assert!(validate_identifier("../escape", "workspace").is_err());
1018 }
1019}