Skip to main content

glass_dev/
daemon.rs

1//! Local authenticated daemon that owns complete development workspaces.
2
3use 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                // A fresh handle models a client reconnecting to the same actor.
1722                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                // The Pi-style broker opens a new process/socket and still
1895                // executes against the same daemon-owned kernel.
1896                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                // A fresh socket observes the process and optional Pi worker
1913                // created by earlier, disconnected clients.
1914                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                // Each request creates a fresh client connection. Reconnecting
2026                // observes the same state but has no trust-mutation operation.
2027                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}