Skip to main content

glass_dev/
daemon.rs

1//! Local authenticated daemon that owns complete development workspaces.
2
3use 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                // The Pi-style broker opens a new process/socket and still
940                // executes against the same daemon-owned kernel.
941                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                // A fresh socket observes the process and optional Pi worker
958                // created by earlier, disconnected clients.
959                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}