use parking_lot::{Mutex, RwLock};
use std::collections::{HashMap, HashSet};
use std::io;
use std::net::IpAddr;
use std::path::{Path, PathBuf};
use std::process::Stdio;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::time::{Duration, SystemTime};
use anyhow::Context;
use axum::extract::{Path as AxumPath, Query, State};
use axum::http::{HeaderMap, StatusCode, header};
use axum::routing::{delete, get, post};
use axum::{Json, Router};
use rmcp::handler::server::wrapper::Parameters;
use serde::{Deserialize, Serialize};
use tokio::net::TcpListener;
use crate::live_index::store::LiveIndex;
use crate::live_index::view::{BaseKey, CommitId, IndexBase, Targets, WorkingSet};
use crate::live_index::{self, SharedIndex};
use crate::paths;
use crate::protocol::SymForgeServer;
use crate::protocol::edit::{
BatchEditInput, BatchInsertInput, BatchRenameInput, DeleteSymbolInput, EditWithinSymbolInput,
InsertSymbolInput, ReplaceSymbolBodyInput,
};
use crate::protocol::read_tools::SymforgeRetrieveInput;
use crate::protocol::tools::{
AnalyzeFileImpactInput, CheckpointNowInput, DetectImpactInput, DiffSymbolsInput, EditPlanInput,
ExploreInput, FindDependentsInput, FindReferencesInput, GetFileContentInput,
GetFileContextInput, GetRepoMapInput, GetSymbolContextInput, GetSymbolInput, HealthInput,
IndexFolderInput, InspectMatchInput, InvestigationInput, SearchFilesInput, SearchSymbolsInput,
SearchTextInput, SmartQueryInput, TraceSymbolInput, ValidateFileSyntaxInput, WhatChangedInput,
search_symbols_options_from_input, search_text_options_from_input,
};
use crate::sidecar::{SidecarState, SymbolSnapshot, TokenStats};
use crate::watcher::{self, WatcherInfo};
const LEGACY_DAEMON_PORT_FILE: &str = "daemon.port";
const LEGACY_DAEMON_PID_FILE: &str = "daemon.pid";
#[cfg(test)]
const LEGACY_DAEMON_START_LOCK_FILE: &str = "daemon.starting";
fn daemon_port_file_name() -> String {
crate::paths::os_tagged_runtime_file_name("daemon", "port")
}
fn daemon_pid_file_name() -> String {
crate::paths::os_tagged_runtime_file_name("daemon", "pid")
}
fn daemon_start_lock_file_name() -> String {
crate::paths::os_tagged_runtime_file_name("daemon", "starting")
}
fn daemon_token_file_name() -> String {
crate::paths::os_tagged_runtime_file_name("daemon", "token")
}
fn read_daemon_runtime(dir: &std::path::Path, tagged: &str, legacy: &str) -> io::Result<String> {
match std::fs::read_to_string(dir.join(tagged)) {
Ok(c) => Ok(c),
Err(e) if e.kind() == io::ErrorKind::NotFound => std::fs::read_to_string(dir.join(legacy)),
Err(e) => Err(e),
}
}
const DAEMON_BIND_ENV: &str = "SYMFORGE_DAEMON_BIND";
const DAEMON_ALLOW_NON_LOOPBACK_ENV: &str = "SYMFORGE_DAEMON_ALLOW_NON_LOOPBACK";
const DAEMON_AUTH_TOKEN_ENV: &str = "SYMFORGE_DAEMON_AUTH_TOKEN";
const TRACE_SYMBOL_ALIAS_DEPRECATION: &str = concat!(
"Deprecation warning: `trace_symbol` is retired; ",
"use `get_symbol_context` with `sections=[...]` or `find_references` instead. ",
"Compatibility policy: keep daemon alias through v7.x; planned removal in v8.0."
);
const DETECT_CHANGES_ALIAS_DEPRECATION: &str = concat!(
"Deprecation warning: `detect_changes` is a CBM-compatibility alias; ",
"use `detect_impact` instead. Compatibility policy: kept for CBM migrator ",
"ergonomics (decision-log D-015-012); no removal date set."
);
pub type SharedDaemonState = Arc<DaemonState>;
pub struct DaemonHandle {
pub port: u16,
pub shutdown_tx: tokio::sync::oneshot::Sender<()>,
pub state: SharedDaemonState,
server_task: tokio::task::JoinHandle<()>,
}
#[derive(Clone)]
pub struct DaemonSessionClient {
http_client: reqwest::Client,
base_url: String,
project_id: String,
session_id: String,
project_name: String,
auth_token: Option<String>,
project_root: Option<PathBuf>,
}
pub struct DaemonState {
next_session_id: AtomicU64,
bases: RwLock<HashMap<BaseKey, Arc<IndexBase>>>,
base_generation_seq: AtomicU64,
projects: RwLock<HashMap<String, ProjectInstance>>,
sessions: RwLock<HashMap<String, SessionRecord>>,
identity: DaemonIdentity,
auth_token: String,
governor: crate::sidecar::governor::RequestGovernor,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum ActivationState {
Inactive,
Activating,
Active,
}
struct ProjectInstance {
project_id: String,
canonical_root: PathBuf,
project_name: String,
index: SharedIndex,
watcher_info: Arc<Mutex<WatcherInfo>>,
watcher_task: Option<tokio::task::JoinHandle<()>>,
stop_token: Arc<AtomicBool>,
token_stats: Arc<TokenStats>,
symbol_cache: Arc<RwLock<HashMap<String, Vec<SymbolSnapshot>>>>,
session_ids: HashSet<String>,
opened_at: SystemTime,
activation_state: ActivationState,
server: SymForgeServer,
}
struct SessionRecord {
session_id: String,
active_project_id: String,
working_set: Arc<RwLock<WorkingSet>>,
client_name: String,
pid: Option<u32>,
opened_at: SystemTime,
last_seen_at: AtomicU64,
}
impl Clone for SessionRecord {
fn clone(&self) -> Self {
Self {
session_id: self.session_id.clone(),
active_project_id: self.active_project_id.clone(),
working_set: Arc::clone(&self.working_set),
client_name: self.client_name.clone(),
pid: self.pid,
opened_at: self.opened_at,
last_seen_at: AtomicU64::new(self.last_seen_at.load(Ordering::Relaxed)),
}
}
}
impl SessionRecord {
fn last_seen_at_time(&self) -> SystemTime {
let millis = self.last_seen_at.load(Ordering::Relaxed);
SystemTime::UNIX_EPOCH + Duration::from_millis(millis)
}
}
fn now_epoch_millis() -> u64 {
SystemTime::now()
.duration_since(SystemTime::UNIX_EPOCH)
.unwrap_or_default()
.as_millis() as u64
}
fn daemon_auth_token_from_env() -> Option<String> {
std::env::var(DAEMON_AUTH_TOKEN_ENV)
.ok()
.map(|value| value.trim().to_string())
.filter(|value| !value.is_empty())
}
fn daemon_auth_token_from_file() -> Option<String> {
let dir = daemon_dir().ok()?;
let contents = std::fs::read_to_string(dir.join(daemon_token_file_name())).ok()?;
let trimmed = contents.trim().to_string();
if trimmed.is_empty() {
None
} else {
Some(trimmed)
}
}
pub(crate) fn resolve_daemon_auth_token() -> Option<String> {
daemon_auth_token_from_env().or_else(daemon_auth_token_from_file)
}
fn generate_daemon_auth_token() -> String {
#[cfg(unix)]
{
use std::io::Read;
if let Ok(mut f) = std::fs::File::open("/dev/urandom") {
let mut buf = [0u8; 32];
if f.read_exact(&mut buf).is_ok() {
return crate::hash::digest_hex(&buf);
}
}
}
use std::sync::atomic::{AtomicU64, Ordering};
static COUNTER: AtomicU64 = AtomicU64::new(0);
let mut seed: Vec<u8> = Vec::with_capacity(64);
let now_nanos = SystemTime::now()
.duration_since(SystemTime::UNIX_EPOCH)
.unwrap_or_default()
.as_nanos();
seed.extend_from_slice(&now_nanos.to_le_bytes());
let mono = std::time::Instant::now();
seed.extend_from_slice(&format!("{mono:?}").into_bytes());
seed.extend_from_slice(&std::process::id().to_le_bytes());
seed.extend_from_slice(&COUNTER.fetch_add(1, Ordering::Relaxed).to_le_bytes());
let boxed = Box::new(0u8);
let addr = (&*boxed as *const u8) as usize;
seed.extend_from_slice(&addr.to_le_bytes());
seed.extend_from_slice(format!("{:?}", std::thread::current().id()).as_bytes());
crate::hash::digest_hex(&seed)
}
fn establish_daemon_auth_token() -> String {
daemon_auth_token_from_env().unwrap_or_else(generate_daemon_auth_token)
}
fn write_daemon_token_file(token: &str) -> io::Result<()> {
let path = daemon_dir()?.join(daemon_token_file_name());
#[cfg(unix)]
{
use std::io::Write;
use std::os::unix::fs::OpenOptionsExt;
use std::os::unix::fs::PermissionsExt;
let mut file = std::fs::OpenOptions::new()
.write(true)
.create(true)
.truncate(true)
.mode(0o600)
.open(&path)
.map_err(|e| {
io::Error::new(
e.kind(),
format!("writing daemon token file at {}: {}", path.display(), e),
)
})?;
file.write_all(token.as_bytes()).map_err(|e| {
io::Error::new(
e.kind(),
format!("writing daemon token file at {}: {}", path.display(), e),
)
})?;
let _ = std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600));
Ok(())
}
#[cfg(not(unix))]
{
std::fs::write(&path, token.as_bytes()).map_err(|e| {
io::Error::new(
e.kind(),
format!("writing daemon token file at {}: {}", path.display(), e),
)
})
}
}
fn env_var_truthy(name: &str) -> bool {
std::env::var(name)
.ok()
.map(|value| {
matches!(
value.trim().to_ascii_lowercase().as_str(),
"1" | "true" | "yes" | "on"
)
})
.unwrap_or(false)
}
fn is_loopback_bind_host(host: &str) -> bool {
let trimmed = host.trim().trim_start_matches('[').trim_end_matches(']');
trimmed.eq_ignore_ascii_case("localhost")
|| trimmed
.parse::<IpAddr>()
.map(|ip| ip.is_loopback())
.unwrap_or(false)
}
fn resolve_daemon_bind_host(default_host: &str) -> anyhow::Result<String> {
let configured = std::env::var(DAEMON_BIND_ENV).unwrap_or_else(|_| default_host.to_string());
let host = configured.trim();
if host.is_empty() {
anyhow::bail!("{DAEMON_BIND_ENV} must not be empty");
}
if is_loopback_bind_host(host) {
return Ok(host.to_string());
}
if env_var_truthy(DAEMON_ALLOW_NON_LOOPBACK_ENV) {
tracing::warn!(
bind_host = %host,
allow_env = DAEMON_ALLOW_NON_LOOPBACK_ENV,
"daemon binding to a non-loopback interface after explicit operator opt-in"
);
Ok(host.to_string())
} else {
anyhow::bail!(
"refusing non-loopback daemon bind '{host}'; set {DAEMON_ALLOW_NON_LOOPBACK_ENV}=1 to allow it explicitly"
);
}
}
fn daemon_socket_bind_address(host: &str) -> String {
let host = host.trim();
if host.contains(':') && !host.starts_with('[') {
format!("[{host}]:0")
} else {
format!("{host}:0")
}
}
fn apply_daemon_auth_header(
request: reqwest::RequestBuilder,
auth_token: Option<&str>,
) -> reqwest::RequestBuilder {
if let Some(token) = auth_token {
request.bearer_auth(token)
} else {
request
}
}
fn constant_time_eq(a: &[u8], b: &[u8]) -> bool {
if a.len() != b.len() {
return false;
}
let mut acc: u8 = 0;
for (lhs, rhs) in a.iter().zip(b.iter()) {
acc |= lhs ^ rhs;
}
acc == 0
}
fn authorize_daemon_request(state: &DaemonState, headers: &HeaderMap) -> Result<(), StatusCode> {
let expected_token = state.auth_token.as_str();
let Some(header_value) = headers
.get(header::AUTHORIZATION)
.and_then(|value| value.to_str().ok())
else {
return Err(StatusCode::UNAUTHORIZED);
};
let Some((scheme, provided_token)) = header_value.split_once(' ') else {
return Err(StatusCode::UNAUTHORIZED);
};
if !scheme.eq_ignore_ascii_case("bearer") {
return Err(StatusCode::UNAUTHORIZED);
}
let expected_digest = crate::hash::digest(expected_token.as_bytes());
let provided_digest = crate::hash::digest(provided_token.as_bytes());
if constant_time_eq(&expected_digest, &provided_digest) {
Ok(())
} else {
Err(StatusCode::UNAUTHORIZED)
}
}
fn daemon_auth_error(status: StatusCode) -> (StatusCode, String) {
(status, "daemon authentication required".to_string())
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct OpenProjectRequest {
pub project_root: String,
pub client_name: String,
pub pid: Option<u32>,
}
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
pub struct OpenProjectResponse {
pub project_id: String,
pub session_id: String,
pub project_name: String,
pub canonical_root: String,
pub session_count: usize,
}
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
pub struct CloseSessionResponse {
pub session_id: String,
pub project_id: String,
pub remaining_sessions: usize,
pub project_removed: bool,
}
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
pub struct HeartbeatResponse {
pub session_id: String,
pub known_session: bool,
}
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
pub struct ProjectSummary {
pub project_id: String,
pub project_name: String,
pub canonical_root: String,
pub session_count: usize,
pub opened_at_unix_secs: u64,
}
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
pub struct SessionSummary {
pub session_id: String,
pub project_id: String,
pub client_name: String,
pub pid: Option<u32>,
pub opened_at_unix_secs: u64,
pub last_seen_at_unix_secs: u64,
}
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
pub struct ProjectHealth {
pub project_id: String,
pub project_name: String,
pub canonical_root: String,
pub session_count: usize,
pub file_count: usize,
pub symbol_count: usize,
pub index_state: String,
pub opened_at_unix_secs: u64,
}
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
pub struct DaemonHealth {
pub project_count: usize,
pub session_count: usize,
pub daemon_version: String,
pub executable_path: String,
#[serde(default)]
pub auth_required: bool,
#[serde(default)]
pub pid: Option<u32>,
}
#[derive(Clone)]
struct SessionRuntime {
canonical_root: PathBuf,
project_id: String,
session_id: String,
index: SharedIndex,
token_stats: Arc<TokenStats>,
symbol_cache: Arc<RwLock<HashMap<String, Vec<SymbolSnapshot>>>>,
server: SymForgeServer,
working_set: Arc<RwLock<WorkingSet>>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct DaemonIdentity {
version: String,
executable_path: String,
}
impl DaemonState {
pub fn new() -> Self {
Self::with_token(establish_daemon_auth_token())
}
fn with_token(auth_token: String) -> Self {
Self {
next_session_id: AtomicU64::new(1),
bases: RwLock::new(HashMap::new()),
base_generation_seq: AtomicU64::new(1),
projects: RwLock::new(HashMap::new()),
sessions: RwLock::new(HashMap::new()),
identity: current_daemon_identity(),
auth_token,
governor: crate::sidecar::governor::RequestGovernor::new(),
}
}
fn intern_base(&self, candidate: Arc<IndexBase>) -> Arc<IndexBase> {
let mut bases = self.bases.write();
if let Some(existing) = bases.get(&candidate.key) {
return Arc::clone(existing);
}
let generation = self.base_generation_seq.fetch_add(1, Ordering::Relaxed);
let mut published = (*candidate).clone();
published.base_generation = generation;
let published = Arc::new(published);
bases.insert(published.key.clone(), Arc::clone(&published));
published
}
fn intern_base_refresh(&self, candidate: Arc<IndexBase>) -> Arc<IndexBase> {
let mut bases = self.bases.write();
let generation = self.base_generation_seq.fetch_add(1, Ordering::Relaxed);
let mut published = (*candidate).clone();
published.base_generation = generation;
let published = Arc::new(published);
bases.insert(published.key.clone(), Arc::clone(&published));
published
}
fn intern_base_for_project(&self, project_id: &str) -> Option<Arc<IndexBase>> {
let candidate = {
let projects = self.projects.read();
projects.get(project_id).map(ProjectInstance::base)
}; candidate.map(|candidate| self.intern_base(candidate))
}
fn refresh_working_set_bases(&self, working_set: &Arc<RwLock<WorkingSet>>, targets: &Targets) {
let targeted: Vec<(String, Arc<LiveIndex>)> = {
let ws = working_set.read();
ws.iter()
.filter(|entry| targets_selects(targets, &entry.project_id))
.map(|entry| (entry.project_id.clone(), Arc::clone(&entry.base.index)))
.collect()
};
if targeted.is_empty() {
return;
}
let stale: Vec<(String, Arc<IndexBase>)> = {
let projects = self.projects.read();
targeted
.iter()
.filter_map(|(project_id, entry_index)| {
let project = projects.get(project_id)?;
let current = project.index.read();
if Arc::ptr_eq(¤t, entry_index) {
None } else {
Some((project_id.clone(), project.base()))
}
})
.collect()
}; if stale.is_empty() {
return; }
let fresh: Vec<(String, Arc<IndexBase>)> = stale
.into_iter()
.map(|(project_id, candidate)| (project_id, self.intern_base_refresh(candidate)))
.collect();
let mut ws = working_set.write();
for (project_id, base) in fresh {
ws.add(project_id, base);
}
drop(ws);
self.gc_orphaned_bases();
}
fn gc_orphaned_bases(&self) {
self.bases
.write()
.retain(|_key, base| Arc::strong_count(base) > 1);
}
fn register_session_for_existing_project(
&self,
project_id: &str,
request: &OpenProjectRequest,
canonical_root: &Path,
) -> anyhow::Result<OpenProjectResponse> {
let session_id = format!(
"session-{}",
self.next_session_id.fetch_add(1, Ordering::Relaxed)
);
let now = SystemTime::now();
let (project_name, canonical_root_text, session_count) = {
let mut projects = self.projects.write();
if !projects.contains_key(project_id) {
let mut reloaded = ProjectInstance::load(canonical_root)?;
if reloaded.activation_state == ActivationState::Inactive {
reloaded.activate();
}
projects.insert(project_id.to_string(), reloaded);
}
let project = projects
.get_mut(project_id)
.expect("project present: inserted above under this same write lock when absent");
project.session_ids.insert(session_id.clone());
(
project.project_name.clone(),
normalized_path_string(&project.canonical_root),
project.session_ids.len(),
)
};
let base = self.intern_base_for_project(project_id);
let mut working_set = WorkingSet::new();
if let Some(base) = base {
working_set.add(project_id.to_string(), base);
}
let session = SessionRecord {
session_id: session_id.clone(),
active_project_id: project_id.to_string(),
working_set: Arc::new(RwLock::new(working_set)),
client_name: request.client_name.clone(),
pid: request.pid,
opened_at: now,
last_seen_at: AtomicU64::new(now_epoch_millis()),
};
self.sessions.write().insert(session_id.clone(), session);
Ok(OpenProjectResponse {
project_id: project_id.to_string(),
session_id,
project_name,
canonical_root: canonical_root_text,
session_count,
})
}
pub fn open_project_session(
&self,
request: OpenProjectRequest,
) -> anyhow::Result<OpenProjectResponse> {
let canonical_root = canonical_project_root(Path::new(&request.project_root))?;
if crate::paths::is_sensitive_path(&canonical_root) {
anyhow::bail!(
"Refused to open session for sensitive system path: {}. Use a project directory instead.",
canonical_root.display()
);
}
let project_id = project_key(&canonical_root);
{
let projects = self.projects.read();
if projects.contains_key(&project_id) {
drop(projects);
return self.register_session_for_existing_project(
&project_id,
&request,
&canonical_root,
);
}
}
let new_project = ProjectInstance::load(&canonical_root)?;
{
let mut projects = self.projects.write();
if projects.contains_key(&project_id) {
} else {
projects.insert(project_id.clone(), new_project);
if let Some(project) = projects.get_mut(&project_id)
&& project.activation_state == ActivationState::Inactive
{
project.activate();
}
}
}
self.register_session_for_existing_project(&project_id, &request, &canonical_root)
}
pub fn heartbeat(&self, session_id: &str) -> HeartbeatResponse {
let known_session = self
.sessions
.read()
.get(session_id)
.map(|session| {
session
.last_seen_at
.store(now_epoch_millis(), Ordering::Relaxed);
true
})
.unwrap_or(false);
HeartbeatResponse {
session_id: session_id.to_string(),
known_session,
}
}
pub fn close_session(&self, session_id: &str) -> Option<CloseSessionResponse> {
let active_project_id = self
.sessions
.read()
.get(session_id)
.map(|s| s.active_project_id.clone());
let mut active_remaining = 0usize;
let mut active_removed = false;
let mut active_pid_seen = false;
{
let mut projects = self.projects.write();
let owning: Vec<String> = projects
.iter()
.filter(|(_, project)| project.session_ids.contains(session_id))
.map(|(id, _)| id.clone())
.collect();
for pid in owning {
let is_active = active_project_id.as_deref() == Some(pid.as_str());
let remaining = {
let Some(project) = projects.get_mut(&pid) else {
continue;
};
project.session_ids.remove(session_id);
project.session_ids.len()
};
let removed = if remaining == 0 {
if let Some(mut removed) = projects.remove(&pid) {
abort_watcher_task(&mut removed.watcher_task, &removed.stop_token);
}
true
} else {
false
};
if is_active {
active_pid_seen = true;
active_remaining = remaining;
active_removed = removed;
}
}
}
let session = self.sessions.write().remove(session_id)?;
let closed_session_id = session.session_id.clone();
drop(session);
self.gc_orphaned_bases();
let project_id = match (active_project_id, active_pid_seen) {
(Some(pid), true) => pid,
_ => "orphan".to_string(),
};
Some(CloseSessionResponse {
session_id: closed_session_id,
project_id,
remaining_sessions: active_remaining,
project_removed: active_removed,
})
}
pub fn list_projects(&self) -> Vec<ProjectSummary> {
let projects = self.projects.read();
let mut summaries: Vec<ProjectSummary> = projects
.values()
.map(|project| ProjectSummary {
project_id: project.project_id.clone(),
project_name: project.project_name.clone(),
canonical_root: normalized_path_string(&project.canonical_root),
session_count: project.session_ids.len(),
opened_at_unix_secs: unix_seconds(project.opened_at),
})
.collect();
summaries.sort_by(|a, b| a.canonical_root.cmp(&b.canonical_root));
summaries
}
pub fn project_health(&self, project_id: &str) -> Option<ProjectHealth> {
let projects = self.projects.read();
let project = projects.get(project_id)?;
let published = project.index.published_state();
Some(ProjectHealth {
project_id: project.project_id.clone(),
project_name: project.project_name.clone(),
canonical_root: normalized_path_string(&project.canonical_root),
session_count: project.session_ids.len(),
file_count: published.file_count,
symbol_count: published.symbol_count,
index_state: published.status_label().to_string(),
opened_at_unix_secs: unix_seconds(project.opened_at),
})
}
pub fn list_sessions(&self, project_id: &str) -> Option<Vec<SessionSummary>> {
let session_ids: Vec<String> = {
let projects = self.projects.read();
let project = projects.get(project_id)?;
project.session_ids.iter().cloned().collect()
};
let sessions = self.sessions.read();
let mut summaries: Vec<SessionSummary> = session_ids
.iter()
.filter_map(|session_id| sessions.get(session_id))
.map(|session| SessionSummary {
session_id: session.session_id.clone(),
project_id: session.active_project_id.clone(),
client_name: session.client_name.clone(),
pid: session.pid,
opened_at_unix_secs: unix_seconds(session.opened_at),
last_seen_at_unix_secs: unix_seconds(session.last_seen_at_time()),
})
.collect();
summaries.sort_by(|a, b| a.session_id.cmp(&b.session_id));
Some(summaries)
}
fn index_folder_for_session(
&self,
session_id: &str,
input: IndexFolderInput,
) -> anyhow::Result<String> {
let target_root = canonical_project_root(Path::new(&input.path))?;
if crate::paths::is_sensitive_path(&target_root) {
return Ok(format!(
"Refused to index sensitive system path: {}. Use a project directory instead.",
target_root.display()
));
}
let target_project_id = project_key(&target_root);
if input.add == Some(true) {
return self.index_folder_additive(session_id, &target_project_id, &target_root);
}
let current_session_root = {
let projects = self.projects.read();
let sessions = self.sessions.read();
let session = sessions
.get(session_id)
.ok_or_else(|| anyhow::anyhow!("unknown session '{session_id}'"))?;
projects
.get(&session.active_project_id)
.map(|project| project.canonical_root.clone())
};
let reset_requested = crate::protocol::tools::index_folder_reset_requested();
let idempotency = match input.idempotency_key.as_deref() {
Some(raw_key) => match crate::idempotency::begin_index_folder_replay(
&target_root,
current_session_root.as_deref(),
&target_root,
raw_key,
reset_requested,
) {
Ok(crate::idempotency::ReplayStart::FirstExecution(active)) => Some(active),
Ok(crate::idempotency::ReplayStart::Replay(response)) => return Ok(response),
Err(error) => return Ok(crate::idempotency::format_tool_error(&error)),
},
None => None,
};
let reload_result = (|| -> anyhow::Result<(usize, usize, bool)> {
let mut projects = self.projects.write();
let current_project_id = {
let sessions = self.sessions.read();
sessions
.get(session_id)
.map(|s| s.active_project_id.clone())
.ok_or_else(|| anyhow::anyhow!("unknown session '{session_id}'"))?
};
let needs_reassign = current_project_id != target_project_id;
if needs_reassign {
if !projects.contains_key(&target_project_id) {
let mut project = ProjectInstance::load(&target_root)?;
debug_assert_eq!(
project.activation_state,
ActivationState::Inactive,
"freshly loaded project must be Inactive"
);
project.activate();
projects.insert(target_project_id.clone(), project);
}
if let Some(current_project) = projects.get_mut(¤t_project_id) {
current_project.session_ids.remove(session_id);
}
if let Some(target_project) = projects.get_mut(&target_project_id) {
target_project.session_ids.insert(session_id.to_string());
}
let should_remove_old = projects
.get(¤t_project_id)
.map(|project| project.session_ids.is_empty())
.unwrap_or(false);
if should_remove_old && let Some(mut removed) = projects.remove(¤t_project_id)
{
abort_watcher_task(&mut removed.watcher_task, &removed.stop_token);
}
}
let target_project = projects
.get_mut(&target_project_id)
.ok_or_else(|| anyhow::anyhow!("missing target project after reload"))?;
let counts = target_project.reload(&target_root)?;
Ok((counts.0, counts.1, needs_reassign))
})();
let (file_count, symbol_count, needs_reassign) = match reload_result {
Ok(counts) => counts,
Err(error) => {
if let Some(idempotency) = &idempotency {
let _ = idempotency.fail(format!("Index failed: {error}"));
}
return Err(error);
}
};
if needs_reassign {
let new_base = self.intern_base_for_project(&target_project_id);
if let Some(session) = self.sessions.write().get_mut(session_id) {
let old_active =
std::mem::replace(&mut session.active_project_id, target_project_id.clone());
if let Some(base) = new_base {
let mut working_set = session.working_set.write();
if old_active != target_project_id {
working_set.remove(&old_active);
}
working_set.add(target_project_id.clone(), base);
}
session
.last_seen_at
.store(now_epoch_millis(), Ordering::Relaxed);
}
}
let mut output = format!("Indexed {} files, {} symbols.", file_count, symbol_count);
if let Some(idempotency) = &idempotency
&& let Err(error) = idempotency.complete(output.clone())
{
output.push_str(&format!(
"\nIdempotency warning: failed to store replay result: {error}"
));
}
Ok(output)
}
fn index_folder_additive(
&self,
session_id: &str,
target_project_id: &str,
target_root: &Path,
) -> anyhow::Result<String> {
let (file_count, symbol_count) = {
let mut projects = self.projects.write();
{
let sessions = self.sessions.read();
if !sessions.contains_key(session_id) {
return Err(anyhow::anyhow!("unknown session '{session_id}'"));
}
}
if !projects.contains_key(target_project_id) {
let mut project = ProjectInstance::load(target_root)?;
debug_assert_eq!(
project.activation_state,
ActivationState::Inactive,
"freshly loaded project must be Inactive"
);
project.activate();
projects.insert(target_project_id.to_string(), project);
}
let target_project = projects
.get_mut(target_project_id)
.ok_or_else(|| anyhow::anyhow!("missing target project after load"))?;
target_project.session_ids.insert(session_id.to_string());
target_project.reload(target_root)?
};
if !self.add_project_to_session(session_id, target_project_id) {
return Err(anyhow::anyhow!(
"failed to attach project to session working set after additive load"
));
}
Ok(format!(
"Indexed {file_count} files, {symbol_count} symbols (added to working set)."
))
}
fn add_project_to_session(&self, session_id: &str, project_id: &str) -> bool {
let Some(base) = self.intern_base_for_project(project_id) else {
return false;
};
{
let mut projects = self.projects.write();
let Some(project) = projects.get_mut(project_id) else {
return false;
};
project.session_ids.insert(session_id.to_string());
}
match self.sessions.write().get_mut(session_id) {
Some(session) => {
session
.working_set
.write()
.add(project_id.to_string(), base);
true
}
None => false,
}
}
#[allow(dead_code)]
fn set_active_project(&self, session_id: &str, project_id: &str) -> bool {
match self.sessions.write().get_mut(session_id) {
Some(session) => {
let is_open = session.working_set.read().get(project_id).is_some();
if !is_open {
return false;
}
session.active_project_id = project_id.to_string();
session
.last_seen_at
.store(now_epoch_millis(), Ordering::Relaxed);
true
}
None => false,
}
}
#[allow(dead_code)]
fn remove_project_from_session(&self, session_id: &str, project_id: &str) -> bool {
let removed = match self.sessions.write().get_mut(session_id) {
Some(session) => {
if session.active_project_id == project_id {
return false;
}
let mut working_set = session.working_set.write();
working_set.remove(project_id).is_some()
}
None => false,
};
if !removed {
return false;
}
let mut projects = self.projects.write();
if let Some(project) = projects.get_mut(project_id) {
project.session_ids.remove(session_id);
if project.session_ids.is_empty()
&& let Some(mut evicted) = projects.remove(project_id)
{
abort_watcher_task(&mut evicted.watcher_task, &evicted.stop_token);
}
}
true
}
fn session_runtime(&self, session_id: &str) -> Option<SessionRuntime> {
let projects = self.projects.read();
let session = {
let sessions = self.sessions.read();
sessions.get(session_id)?.clone()
};
let project = projects.get(&session.active_project_id)?;
Some(SessionRuntime {
canonical_root: project.canonical_root.clone(),
project_id: session.active_project_id.clone(),
session_id: session.session_id.clone(),
index: Arc::clone(&project.index),
token_stats: Arc::clone(&project.token_stats),
symbol_cache: Arc::clone(&project.symbol_cache),
server: project.server.clone(),
working_set: Arc::clone(&session.working_set),
})
}
pub fn health(&self) -> DaemonHealth {
DaemonHealth {
project_count: self.projects.read().len(),
session_count: self.sessions.read().len(),
daemon_version: self.identity.version.clone(),
executable_path: self.identity.executable_path.clone(),
auth_required: true,
pid: Some(std::process::id()),
}
}
}
impl Default for DaemonState {
fn default() -> Self {
Self::new()
}
}
impl DaemonSessionClient {
fn new_with_auth_token(
base_url: String,
project_id: String,
session_id: String,
project_name: String,
auth_token: Option<String>,
) -> Self {
let http_client = reqwest::Client::builder()
.connect_timeout(std::time::Duration::from_secs(5))
.timeout(std::time::Duration::from_secs(60))
.build()
.expect("failed to build reqwest client with timeout — this is a critical invariant");
Self {
http_client,
base_url,
project_id,
session_id,
project_name,
auth_token,
project_root: None,
}
}
fn with_project_root(mut self, root: PathBuf) -> Self {
self.project_root = Some(root);
self
}
#[cfg(test)]
pub(crate) fn new_for_test(
base_url: String,
project_id: String,
session_id: String,
project_name: String,
) -> Self {
Self::new_with_auth_token(
base_url,
project_id,
session_id,
project_name,
resolve_daemon_auth_token(),
)
}
pub fn project_name(&self) -> &str {
&self.project_name
}
pub fn project_id(&self) -> &str {
&self.project_id
}
pub fn session_id(&self) -> &str {
&self.session_id
}
pub fn base_url(&self) -> &str {
&self.base_url
}
pub fn project_root(&self) -> Option<&Path> {
self.project_root.as_deref()
}
pub fn port(&self) -> Option<u16> {
self.base_url
.rsplit(':')
.next()
.and_then(|value| value.parse::<u16>().ok())
}
pub async fn reconnect(&self) -> anyhow::Result<DaemonSessionClient> {
let project_root = self
.project_root
.as_deref()
.context("cannot reconnect: no project root stored")?;
tracing::info!(
"attempting daemon reconnection for project {}",
self.project_name
);
let new_client =
connect_or_spawn_session(project_root, "mcp-stdio", Some(std::process::id())).await?;
Ok(new_client.with_project_root(project_root.to_path_buf()))
}
pub async fn call_tool_value(
&self,
tool_name: &str,
params: serde_json::Value,
) -> anyhow::Result<String> {
let request = self
.http_client
.post(format!(
"{}/v1/sessions/{}/tools/{}",
self.base_url, self.session_id, tool_name
))
.json(¶ms);
let request = apply_daemon_auth_header(request, self.auth_token.as_deref()).header(
crate::protocol::surface_probe::CONNECTION_SURFACE_HEADER,
crate::protocol::surface_probe::surface_profile_label(
crate::protocol::surface_probe::surface_profile_from_env(),
),
);
let response = request
.send()
.await
.with_context(|| format!("calling daemon tool '{tool_name}'"))?
.error_for_status()
.with_context(|| format!("daemon rejected tool '{tool_name}'"))?;
response
.text()
.await
.with_context(|| format!("reading daemon tool response for '{tool_name}'"))
}
pub async fn heartbeat(&self) -> anyhow::Result<HeartbeatResponse> {
let request = self.http_client.post(format!(
"{}/v1/sessions/{}/heartbeat",
self.base_url, self.session_id
));
apply_daemon_auth_header(request, self.auth_token.as_deref())
.send()
.await
.context("sending daemon heartbeat")?
.error_for_status()
.context("daemon heartbeat status")?
.json::<HeartbeatResponse>()
.await
.context("daemon heartbeat body")
}
pub async fn close(&self) -> anyhow::Result<CloseSessionResponse> {
let request = self
.http_client
.delete(format!("{}/v1/sessions/{}", self.base_url, self.session_id));
apply_daemon_auth_header(request, self.auth_token.as_deref())
.send()
.await
.context("closing daemon session")?
.error_for_status()
.context("daemon close status")?
.json::<CloseSessionResponse>()
.await
.context("daemon close body")
}
}
struct DaemonStartLock {
path: PathBuf,
}
impl Drop for DaemonStartLock {
fn drop(&mut self) {
let _ = std::fs::remove_file(&self.path);
}
}
pub async fn connect_or_spawn_session(
project_root: &Path,
client_name: &str,
pid: Option<u32>,
) -> anyhow::Result<DaemonSessionClient> {
let port = ensure_daemon_running().await?;
let base_url = format!("http://127.0.0.1:{port}");
let http_client = reqwest::Client::builder()
.connect_timeout(Duration::from_secs(5))
.timeout(Duration::from_secs(60))
.build()
.context("building reqwest client for connect_or_spawn_session")?;
let auth_token = resolve_daemon_auth_token();
let open_request = http_client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project_root.display().to_string(),
client_name: client_name.to_string(),
pid,
});
let opened = apply_daemon_auth_header(open_request, auth_token.as_deref())
.send()
.await
.context("opening daemon session")?
.error_for_status()
.context("daemon session open status")?
.json::<OpenProjectResponse>()
.await
.context("daemon session open body")?;
Ok(DaemonSessionClient::new_with_auth_token(
base_url,
opened.project_id,
opened.session_id,
opened.project_name,
auth_token,
)
.with_project_root(project_root.to_path_buf()))
}
async fn ensure_daemon_running() -> anyhow::Result<u16> {
let identity = current_daemon_identity();
if let Some(port) = daemon_port_if_compatible(&identity).await? {
tracing::debug!("daemon already running on port {port}");
return Ok(port);
}
if let Some(_lock) = try_acquire_start_lock()? {
if let Some(port) = daemon_port_if_compatible(&identity).await? {
tracing::debug!("daemon became ready while acquiring lock, port {port}");
return Ok(port);
}
tracing::info!("acquired start lock, spawning new daemon");
stop_incompatible_recorded_daemon(&identity).await?;
spawn_daemon_process()?;
wait_for_daemon_ready(&identity).await
} else {
tracing::info!("start lock held by another process, waiting for daemon");
wait_for_daemon_ready(&identity).await
}
}
async fn daemon_port_if_compatible(identity: &DaemonIdentity) -> anyhow::Result<Option<u16>> {
let port = match read_daemon_port_file() {
Ok(port) => port,
Err(error) if error.kind() == io::ErrorKind::NotFound => return Ok(None),
Err(error) if error.kind() == io::ErrorKind::InvalidData => {
tracing::warn!("ignoring corrupt symforge daemon port file: {error}");
return Ok(None);
}
Err(error) => return Err(error).context("reading daemon port file"),
};
match daemon_health(port).await {
Some(health) if daemon_health_matches(&health, identity) => Ok(Some(port)),
Some(health) => {
tracing::warn!(
recorded_port = port,
recorded_version = %health.daemon_version,
expected_version = %identity.version,
recorded_executable = %health.executable_path,
expected_executable = %identity.executable_path,
"recorded symforge daemon is incompatible with the current executable"
);
Ok(None)
}
None => Ok(None),
}
}
async fn wait_for_daemon_ready(identity: &DaemonIdentity) -> anyhow::Result<u16> {
let deadline = tokio::time::Instant::now() + tokio::time::Duration::from_secs(5);
loop {
if let Some(port) = daemon_port_if_compatible(identity).await? {
return Ok(port);
}
if tokio::time::Instant::now() >= deadline {
anyhow::bail!("timed out waiting for symforge daemon to become ready");
}
tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
}
}
async fn daemon_health(port: u16) -> Option<DaemonHealth> {
let client = reqwest::Client::builder()
.connect_timeout(Duration::from_secs(5))
.timeout(Duration::from_secs(10))
.build()
.ok()?;
client
.get(format!("http://127.0.0.1:{port}/health"))
.send()
.await
.ok()?
.error_for_status()
.ok()?
.json::<DaemonHealth>()
.await
.ok()
}
async fn daemon_health_ok(port: u16) -> bool {
daemon_health(port).await.is_some()
}
async fn stop_incompatible_recorded_daemon(identity: &DaemonIdentity) -> anyhow::Result<()> {
let port = match read_daemon_port_file() {
Ok(port) => port,
Err(error) if error.kind() == io::ErrorKind::NotFound => return Ok(()),
Err(error) if error.kind() == io::ErrorKind::InvalidData => {
tracing::warn!("removing corrupt symforge daemon port file: {error}");
cleanup_daemon_runtime_files();
return Ok(());
}
Err(error) => return Err(error).context("reading daemon port file"),
};
let Some(health) = daemon_health(port).await else {
cleanup_daemon_runtime_files();
return Ok(());
};
if daemon_health_matches(&health, identity) {
return Ok(());
}
if let Ok(pid) = read_daemon_pid_file() {
if should_terminate_recorded_daemon(&health, identity, pid) {
if let Err(error) = terminate_process(pid) {
tracing::warn!(
pid,
"failed to terminate incompatible symforge daemon automatically: {error}"
);
}
wait_for_daemon_unhealthy(port).await;
} else if !daemon_health_matches_recorded_pid(&health, pid) {
match health.pid {
Some(health_pid) => {
tracing::warn!(
recorded_pid = pid,
daemon_pid = health_pid,
"not terminating incompatible symforge daemon because the pid file does not match health"
);
}
None => {
tracing::warn!(
recorded_pid = pid,
"not terminating incompatible symforge daemon because health did not report a pid"
);
}
}
} else {
tracing::warn!(
recorded_pid = pid,
daemon_pid = ?health.pid,
recorded_executable = %health.executable_path,
expected_executable = %identity.executable_path,
"not terminating incompatible symforge daemon because pid ownership/executable safety checks failed"
);
}
}
cleanup_daemon_runtime_files();
Ok(())
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) enum DaemonStopOutcome {
NotRunning,
Stopped { pid: u32 },
StopTimedOut { pid: u32 },
SkippedSafety,
}
#[allow(unsafe_code)] pub(crate) async fn stop_running_daemon_for_update() -> anyhow::Result<DaemonStopOutcome> {
let port = match read_daemon_port_file() {
Ok(port) => port,
Err(error) if error.kind() == io::ErrorKind::NotFound => {
return Ok(DaemonStopOutcome::NotRunning);
}
Err(error) if error.kind() == io::ErrorKind::InvalidData => {
tracing::warn!("removing corrupt symforge daemon port file during update: {error}");
cleanup_daemon_runtime_files();
return Ok(DaemonStopOutcome::NotRunning);
}
Err(error) => return Err(error).context("reading daemon port file"),
};
let Some(health) = daemon_health(port).await else {
cleanup_daemon_runtime_files();
return Ok(DaemonStopOutcome::NotRunning);
};
let identity = current_daemon_identity();
match read_daemon_pid_file() {
Ok(pid) if should_terminate_recorded_daemon(&health, &identity, pid) => {
if let Err(error) = terminate_process(pid) {
tracing::warn!(
pid,
"failed to terminate symforge daemon during update: {error}"
);
}
wait_for_daemon_unhealthy(port).await;
if process_is_alive(pid) {
#[cfg(unix)]
unsafe {
libc::kill(pid as i32, libc::SIGKILL);
}
for _ in 0..20 {
if !process_is_alive(pid) {
break;
}
tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
}
}
if process_is_alive(pid) {
tracing::warn!(
pid,
"symforge daemon still alive after terminate during update"
);
Ok(DaemonStopOutcome::StopTimedOut { pid })
} else {
cleanup_daemon_runtime_files();
Ok(DaemonStopOutcome::Stopped { pid })
}
}
Ok(_) => Ok(DaemonStopOutcome::SkippedSafety),
Err(_) => {
cleanup_daemon_runtime_files();
Ok(DaemonStopOutcome::NotRunning)
}
}
}
#[allow(unsafe_code)] fn process_is_alive(pid: u32) -> bool {
#[cfg(windows)]
{
crate::process_util::hidden_command("tasklist")
.args(["/FI", &format!("PID eq {pid}"), "/NH", "/FO", "CSV"])
.stdin(Stdio::null())
.stderr(Stdio::null())
.output()
.map(|output| String::from_utf8_lossy(&output.stdout).contains(&pid.to_string()))
.unwrap_or(false)
}
#[cfg(not(windows))]
{
unsafe { libc::kill(pid as i32, 0) == 0 }
}
}
async fn wait_for_daemon_unhealthy(port: u16) {
let deadline = tokio::time::Instant::now() + tokio::time::Duration::from_secs(3);
while tokio::time::Instant::now() < deadline {
if !daemon_health_ok(port).await {
break;
}
tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
}
}
fn try_acquire_start_lock() -> anyhow::Result<Option<DaemonStartLock>> {
let path = daemon_dir()?.join(daemon_start_lock_file_name());
match std::fs::OpenOptions::new()
.write(true)
.create_new(true)
.open(&path)
{
Ok(_) => Ok(Some(DaemonStartLock { path })),
Err(error) if error.kind() == io::ErrorKind::AlreadyExists => {
if let Ok(metadata) = std::fs::metadata(&path)
&& let Ok(modified) = metadata.modified()
&& modified.elapsed().unwrap_or_default() > std::time::Duration::from_secs(30)
{
tracing::warn!("removing stale daemon start lock (age > 30s)");
let _ = std::fs::remove_file(&path);
if std::fs::OpenOptions::new()
.write(true)
.create_new(true)
.open(&path)
.is_ok()
{
return Ok(Some(DaemonStartLock { path }));
}
}
Ok(None)
}
Err(error) => Err(error).context("creating daemon start lock"),
}
}
fn spawn_daemon_process() -> anyhow::Result<()> {
let current_exe = std::env::current_exe().context("locating current symforge executable")?;
let mut command = std::process::Command::new(current_exe);
command
.arg("daemon")
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null());
#[cfg(windows)]
{
use std::os::windows::process::CommandExt;
const DETACHED_PROCESS: u32 = 0x0000_0008;
const CREATE_NO_WINDOW: u32 = 0x0800_0000;
command.creation_flags(DETACHED_PROCESS | CREATE_NO_WINDOW);
}
command
.spawn()
.context("spawning detached symforge daemon")?;
Ok(())
}
fn current_daemon_identity() -> DaemonIdentity {
let executable_path = std::env::current_exe()
.ok()
.map(|path| normalized_path_string(&path))
.unwrap_or_else(|| "unknown".to_string());
DaemonIdentity {
version: env!("CARGO_PKG_VERSION").to_string(),
executable_path,
}
}
fn daemon_health_matches(health: &DaemonHealth, identity: &DaemonIdentity) -> bool {
if health.daemon_version != identity.version {
return false;
}
if health.executable_path == "unknown" || identity.executable_path == "unknown" {
return true;
}
stable_path_identity(&health.executable_path) == stable_path_identity(&identity.executable_path)
}
fn daemon_health_matches_recorded_pid(health: &DaemonHealth, recorded_pid: u32) -> bool {
health.pid == Some(recorded_pid)
}
fn should_terminate_recorded_daemon(
health: &DaemonHealth,
identity: &DaemonIdentity,
recorded_pid: u32,
) -> bool {
if !daemon_health_matches_recorded_pid(health, recorded_pid) {
return false;
}
if !daemon_executable_name_matches_current(health, identity) {
return false;
}
#[cfg(target_os = "linux")]
{
if !recorded_pid_owner_matches_current_user(recorded_pid).unwrap_or(false) {
return false;
}
if !recorded_pid_executable_matches_health(recorded_pid, health).unwrap_or(false) {
return false;
}
}
true
}
fn daemon_executable_name_matches_current(
health: &DaemonHealth,
identity: &DaemonIdentity,
) -> bool {
let Some(health_name) = daemon_executable_file_name(&health.executable_path) else {
return false;
};
let Some(identity_name) = daemon_executable_file_name(&identity.executable_path) else {
return false;
};
health_name == identity_name
}
fn daemon_executable_file_name(path: &str) -> Option<String> {
if path == "unknown" {
return None;
}
let normalized = path.replace('\\', "/");
let name = normalized.rsplit('/').find(|part| !part.is_empty())?;
if cfg!(windows) {
Some(name.to_lowercase())
} else {
Some(name.to_string())
}
}
#[cfg(target_os = "linux")]
#[allow(unsafe_code)] fn recorded_pid_owner_matches_current_user(pid: u32) -> Option<bool> {
let status = std::fs::read_to_string(format!("/proc/{pid}/status")).ok()?;
let uid_line = status.lines().find(|line| line.starts_with("Uid:"))?;
let effective_uid = uid_line.split_whitespace().nth(2)?.parse::<u32>().ok()?;
let current_uid = unsafe { libc::geteuid() as u32 };
Some(effective_uid == current_uid)
}
#[cfg(target_os = "linux")]
fn recorded_pid_executable_matches_health(pid: u32, health: &DaemonHealth) -> Option<bool> {
if health.executable_path == "unknown" {
return None;
}
let actual = std::fs::read_link(format!("/proc/{pid}/exe")).ok()?;
Some(
stable_path_identity(&normalized_path_string(&actual))
== stable_path_identity(&health.executable_path),
)
}
fn stable_path_identity(path: &str) -> String {
let normalized = path.replace('\\', "/");
if cfg!(windows) {
normalized.to_lowercase()
} else {
normalized
}
}
impl ProjectInstance {
fn load(canonical_root: &Path) -> anyhow::Result<Self> {
let project_name = canonical_root
.file_name()
.and_then(|name| name.to_str())
.unwrap_or("project")
.to_string();
let index = bootstrap_project_index(canonical_root)?;
let watcher_info = Arc::new(Mutex::new(WatcherInfo::default()));
let token_stats = TokenStats::new();
let server = SymForgeServer::new(
Arc::clone(&index),
project_name.clone(),
Arc::clone(&watcher_info),
Some(canonical_root.to_path_buf()),
Some(Arc::clone(&token_stats)),
);
Ok(Self {
project_id: project_key(canonical_root),
canonical_root: canonical_root.to_path_buf(),
project_name,
index,
watcher_info,
watcher_task: None,
stop_token: Arc::new(AtomicBool::new(false)),
token_stats,
symbol_cache: Arc::new(RwLock::new(HashMap::new())),
session_ids: HashSet::new(),
opened_at: SystemTime::now(),
activation_state: ActivationState::Inactive,
server,
})
}
fn base(&self) -> Arc<IndexBase> {
let index = Arc::clone(&self.index.read());
let commit = match crate::git::head_sha(&self.canonical_root) {
Ok(sha) => CommitId::Sha(sha),
Err(_) => CommitId::Dirtyless,
};
let key = BaseKey::new(self.canonical_root.clone(), commit);
Arc::new(IndexBase::new(key, index, 1))
}
fn activate(&mut self) {
if self.activation_state != ActivationState::Inactive {
tracing::error!(
project_id = %self.project_id,
state = ?self.activation_state,
"activate() called on a project that is not Inactive — skipping"
);
return;
}
self.activation_state = ActivationState::Activating;
self.stop_token = Arc::new(AtomicBool::new(false));
self.watcher_task = start_project_watcher(
self.canonical_root.clone(),
Arc::clone(&self.index),
Arc::clone(&self.watcher_info),
Arc::clone(&self.stop_token),
);
let expected_gen = self.index.current_project_generation();
live_index::git_temporal::spawn_git_temporal_computation(
Arc::clone(&self.index),
self.canonical_root.clone(),
expected_gen,
);
self.activation_state = ActivationState::Active;
}
fn reload(&mut self, canonical_root: &Path) -> anyhow::Result<(usize, usize)> {
abort_watcher_task(&mut self.watcher_task, &self.stop_token);
self.index.reload(canonical_root)?;
let published = self.index.published_state();
let file_count = published.file_count;
let symbol_count = published.symbol_count;
self.stop_token = Arc::new(AtomicBool::new(false));
self.watcher_task = start_project_watcher(
canonical_root.to_path_buf(),
Arc::clone(&self.index),
Arc::clone(&self.watcher_info),
Arc::clone(&self.stop_token),
);
self.canonical_root = canonical_root.to_path_buf();
self.project_name = canonical_root
.file_name()
.and_then(|name| name.to_str())
.unwrap_or("project")
.to_string();
self.project_id = project_key(canonical_root);
self.server = SymForgeServer::new(
Arc::clone(&self.index),
self.project_name.clone(),
Arc::clone(&self.watcher_info),
Some(canonical_root.to_path_buf()),
Some(Arc::clone(&self.token_stats)),
);
let expected_gen = self.index.current_project_generation();
live_index::git_temporal::spawn_git_temporal_computation(
Arc::clone(&self.index),
canonical_root.to_path_buf(),
expected_gen,
);
Ok((file_count, symbol_count))
}
}
fn bootstrap_project_index(canonical_root: &Path) -> anyhow::Result<SharedIndex> {
if let Some(snapshot) = live_index::persist::load_snapshot(canonical_root) {
let file_count = snapshot.files.len();
let snapshot_mtimes: HashMap<String, u64> = snapshot
.files
.iter()
.map(|(path, file)| (path.clone(), file.mtime_secs))
.collect();
let live = live_index::persist::snapshot_to_live_index(snapshot, canonical_root);
tracing::info!(
files = file_count,
load_source = ?live.load_source(),
root = %canonical_root.display(),
"daemon bootstrap restored index from .symforge snapshot/team artifact"
);
let shared: SharedIndex = live_index::SharedIndexHandle::shared(live);
if let Ok(handle) = tokio::runtime::Handle::try_current() {
let bg_index = shared.clone();
let bg_root = canonical_root.to_path_buf();
handle.spawn(async move {
live_index::persist::background_verify(bg_index, bg_root, snapshot_mtimes).await;
});
}
return Ok(shared);
}
live_index::LiveIndex::load(canonical_root).with_context(|| {
format!(
"failed to load project index for {}",
canonical_root.display()
)
})
}
fn start_project_watcher(
repo_root: PathBuf,
index: SharedIndex,
watcher_info: Arc<Mutex<WatcherInfo>>,
stop_token: Arc<AtomicBool>,
) -> Option<tokio::task::JoinHandle<()>> {
tokio::runtime::Handle::try_current().ok().map(|handle| {
handle.spawn(watcher::run_watcher_with_stop(
repo_root,
index,
watcher_info,
stop_token,
))
})
}
fn abort_watcher_task(
task: &mut Option<tokio::task::JoinHandle<()>>,
stop_token: &Arc<AtomicBool>,
) {
stop_token.store(true, Ordering::Release);
if let Some(task) = task.take() {
task.abort();
}
}
pub fn build_router(state: SharedDaemonState) -> Router {
Router::new()
.route("/health", get(daemon_health_handler))
.route("/v1/projects", get(list_projects_handler))
.route(
"/v1/projects/{project_id}/health",
get(project_health_handler),
)
.route(
"/v1/projects/{project_id}/sessions",
get(list_sessions_handler),
)
.route("/v1/sessions/open", post(open_project_session_handler))
.route(
"/v1/sessions/{session_id}/tools/{tool_name}",
post(call_tool_handler),
)
.route(
"/v1/sessions/{session_id}/sidecar/health",
get(sidecar_health_handler),
)
.route(
"/v1/sessions/{session_id}/sidecar/outline",
get(sidecar_outline_handler),
)
.route(
"/v1/sessions/{session_id}/sidecar/workflows/source-read",
get(sidecar_outline_handler),
)
.route(
"/v1/sessions/{session_id}/sidecar/impact",
get(sidecar_impact_handler),
)
.route(
"/v1/sessions/{session_id}/sidecar/workflows/post-edit-impact",
get(sidecar_impact_handler),
)
.route(
"/v1/sessions/{session_id}/sidecar/symbol-context",
get(sidecar_symbol_context_handler),
)
.route(
"/v1/sessions/{session_id}/sidecar/workflows/search-hit-expansion",
get(sidecar_symbol_context_handler),
)
.route(
"/v1/sessions/{session_id}/sidecar/repo-map",
get(sidecar_repo_map_handler),
)
.route(
"/v1/sessions/{session_id}/sidecar/workflows/repo-start",
get(sidecar_repo_map_handler),
)
.route(
"/v1/sessions/{session_id}/sidecar/prompt-context",
get(sidecar_prompt_context_handler),
)
.route(
"/v1/sessions/{session_id}/sidecar/workflows/prompt-context",
get(sidecar_prompt_context_handler),
)
.route(
"/v1/sessions/{session_id}/sidecar/stats",
get(sidecar_stats_handler),
)
.route(
"/v1/sessions/{session_id}/heartbeat",
post(heartbeat_handler),
)
.route("/v1/sessions/{session_id}", delete(close_session_handler))
.with_state(state)
}
pub async fn spawn_daemon(bind_host: &str) -> anyhow::Result<DaemonHandle> {
let resolved_host = resolve_daemon_bind_host(bind_host)?;
cleanup_daemon_runtime_files();
let listener = TcpListener::bind(daemon_socket_bind_address(&resolved_host)).await?;
let port = listener.local_addr()?.port();
let auth_token = establish_daemon_auth_token();
write_daemon_token_file(&auth_token)?;
write_daemon_port_file(port)?;
write_daemon_pid_file(std::process::id())?;
let state = Arc::new(DaemonState::with_token(auth_token));
let app = build_router(Arc::clone(&state));
let (shutdown_tx, shutdown_rx) = tokio::sync::oneshot::channel::<()>();
let server_task = tokio::spawn(async move {
let shutdown_signal = async move {
let _ = shutdown_rx.await;
};
if let Err(error) = axum::serve(listener, app)
.with_graceful_shutdown(shutdown_signal)
.await
{
tracing::error!("daemon server error: {error}");
}
cleanup_daemon_runtime_files();
});
Ok(DaemonHandle {
port,
shutdown_tx,
state,
server_task,
})
}
pub async fn run_daemon_until_shutdown(bind_host: &str) -> anyhow::Result<()> {
let handle = spawn_daemon(bind_host).await?;
tracing::info!(port = handle.port, "shared daemon started");
#[cfg(unix)]
{
use tokio::signal::unix::{SignalKind, signal};
let mut sigterm = signal(SignalKind::terminate())?;
tokio::select! {
_ = tokio::signal::ctrl_c() => {
tracing::info!("received SIGINT, shutting down");
},
_ = sigterm.recv() => {
tracing::info!("received SIGTERM, shutting down");
},
}
}
#[cfg(not(unix))]
{
tokio::signal::ctrl_c().await?;
tracing::info!("received Ctrl+C, shutting down");
}
let DaemonHandle {
shutdown_tx,
server_task,
..
} = handle;
let _ = shutdown_tx.send(());
match tokio::time::timeout(tokio::time::Duration::from_secs(5), server_task).await {
Ok(Ok(())) => {}
Ok(Err(join_err)) => tracing::warn!("daemon server task ended with join error: {join_err}"),
Err(_) => tracing::warn!("timed out waiting for daemon server task to shut down"),
}
Ok(())
}
async fn daemon_health_handler(State(state): State<SharedDaemonState>) -> Json<DaemonHealth> {
Json(state.health())
}
async fn list_projects_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
) -> Result<Json<Vec<ProjectSummary>>, StatusCode> {
authorize_daemon_request(&state, &headers)?;
Ok(Json(state.list_projects()))
}
async fn project_health_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
AxumPath(project_id): AxumPath<String>,
) -> Result<Json<ProjectHealth>, StatusCode> {
authorize_daemon_request(&state, &headers)?;
state
.project_health(&project_id)
.map(Json)
.ok_or(StatusCode::NOT_FOUND)
}
async fn list_sessions_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
AxumPath(project_id): AxumPath<String>,
) -> Result<Json<Vec<SessionSummary>>, StatusCode> {
authorize_daemon_request(&state, &headers)?;
state
.list_sessions(&project_id)
.map(Json)
.ok_or(StatusCode::NOT_FOUND)
}
async fn open_project_session_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
Json(request): Json<OpenProjectRequest>,
) -> Result<Json<OpenProjectResponse>, (StatusCode, String)> {
authorize_daemon_request(&state, &headers).map_err(daemon_auth_error)?;
let state_for_load = Arc::clone(&state);
let response =
tokio::task::spawn_blocking(move || state_for_load.open_project_session(request))
.await
.map_err(internal_error)?
.map_err(bad_request)?;
Ok(Json(response))
}
fn connection_surface_from_headers(
headers: &HeaderMap,
) -> Option<crate::protocol::surface_probe::SurfaceProfile> {
headers
.get(crate::protocol::surface_probe::CONNECTION_SURFACE_HEADER)
.and_then(|value| value.to_str().ok())
.and_then(crate::protocol::surface_probe::surface_profile_from_label)
}
async fn call_tool_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
AxumPath((session_id, tool_name)): AxumPath<(String, String)>,
Json(params): Json<serde_json::Value>,
) -> Result<String, (StatusCode, String)> {
authorize_daemon_request(&state, &headers).map_err(daemon_auth_error)?;
if tool_name == "index_folder" {
let input = decode_params::<IndexFolderInput>(params).map_err(bad_request)?;
let state_for_index = state.clone();
let session_id_owned = session_id.clone();
return state
.governor
.execute_non_abortable("index_folder", async move {
tokio::task::spawn_blocking(move || {
state_for_index.index_folder_for_session(&session_id_owned, input)
})
.await
.map_err(|join_err| anyhow::anyhow!("index_folder task panicked: {join_err}"))?
})
.await
.map_err(|gov_err| bad_request(gov_err.into()))?
.map_err(bad_request);
}
let runtime = state.session_runtime(&session_id).ok_or_else(|| {
(
StatusCode::NOT_FOUND,
format!("unknown session '{session_id}'"),
)
})?;
let tool_name_owned = tool_name.clone();
let tool_name_for_panic = tool_name.clone();
let state_for_refresh = Arc::clone(&state);
let connection_surface = connection_surface_from_headers(&headers);
match state
.governor
.execute_non_abortable(&tool_name, async move {
let handle = tokio::runtime::Handle::current();
tokio::task::spawn_blocking(move || {
if let Some(targets) =
resolve_cross_project_targets(&tool_name_owned, ¶ms, &runtime.project_id)
{
state_for_refresh.refresh_working_set_bases(&runtime.working_set, &targets);
}
handle.block_on(crate::protocol::surface_probe::with_connection_surface(
connection_surface,
execute_tool_call(runtime, &tool_name_owned, params),
))
})
.await
.map_err(|join_err| anyhow::anyhow!("tool task panicked: {join_err}"))?
})
.await
{
Ok(Ok(result)) => Ok(result),
Ok(Err(tool_err)) => {
Ok(format!("Error in {}: {}", tool_name_for_panic, tool_err))
}
Err(gov_err) => {
let msg = format!(
"Error: tool '{}' failed — {}. The tool did not complete. Do not retry immediately.",
tool_name_for_panic, gov_err
);
tracing::error!(tool = %tool_name_for_panic, "tool execution failed: {gov_err}");
Ok(msg)
}
}
}
async fn sidecar_health_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
AxumPath(session_id): AxumPath<String>,
) -> Result<Json<crate::sidecar::handlers::HealthResponse>, StatusCode> {
authorize_daemon_request(&state, &headers)?;
let runtime = state
.session_runtime(&session_id)
.ok_or(StatusCode::NOT_FOUND)?;
let sidecar = sidecar_state_for_runtime(&runtime);
state
.governor
.execute("sidecar/health", async move {
let handle = tokio::runtime::Handle::current();
tokio::task::spawn_blocking(move || {
handle.block_on(crate::sidecar::handlers::health_handler(State(sidecar)))
})
.await
.unwrap_or(Err(StatusCode::INTERNAL_SERVER_ERROR))
})
.await
.map_err(|_| StatusCode::GATEWAY_TIMEOUT)?
}
async fn sidecar_outline_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
AxumPath(session_id): AxumPath<String>,
Query(params): Query<crate::sidecar::handlers::OutlineParams>,
) -> Result<String, StatusCode> {
authorize_daemon_request(&state, &headers)?;
let runtime = state
.session_runtime(&session_id)
.ok_or(StatusCode::NOT_FOUND)?;
let sidecar = sidecar_state_for_runtime(&runtime);
state
.governor
.execute("sidecar/outline", async move {
let handle = tokio::runtime::Handle::current();
tokio::task::spawn_blocking(move || {
handle.block_on(crate::sidecar::handlers::outline_handler(
State(sidecar),
Query(params),
))
})
.await
.unwrap_or(Err(StatusCode::INTERNAL_SERVER_ERROR))
})
.await
.map_err(|_| StatusCode::GATEWAY_TIMEOUT)?
}
async fn sidecar_impact_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
AxumPath(session_id): AxumPath<String>,
Query(params): Query<crate::sidecar::handlers::ImpactParams>,
) -> Result<String, StatusCode> {
authorize_daemon_request(&state, &headers)?;
let runtime = state
.session_runtime(&session_id)
.ok_or(StatusCode::NOT_FOUND)?;
let sidecar = sidecar_state_for_runtime(&runtime);
state
.governor
.execute("sidecar/impact", async move {
let handle = tokio::runtime::Handle::current();
tokio::task::spawn_blocking(move || {
handle.block_on(crate::sidecar::handlers::impact_handler(
State(sidecar),
Query(params),
))
})
.await
.unwrap_or(Err(StatusCode::INTERNAL_SERVER_ERROR))
})
.await
.map_err(|_| StatusCode::GATEWAY_TIMEOUT)?
}
async fn sidecar_symbol_context_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
AxumPath(session_id): AxumPath<String>,
Query(params): Query<crate::sidecar::handlers::SymbolContextParams>,
) -> Result<String, StatusCode> {
authorize_daemon_request(&state, &headers)?;
let runtime = state
.session_runtime(&session_id)
.ok_or(StatusCode::NOT_FOUND)?;
let sidecar = sidecar_state_for_runtime(&runtime);
state
.governor
.execute("sidecar/symbol-context", async move {
let handle = tokio::runtime::Handle::current();
tokio::task::spawn_blocking(move || {
handle.block_on(crate::sidecar::handlers::symbol_context_handler(
State(sidecar),
Query(params),
))
})
.await
.unwrap_or(Err(StatusCode::INTERNAL_SERVER_ERROR))
})
.await
.map_err(|_| StatusCode::GATEWAY_TIMEOUT)?
}
async fn sidecar_repo_map_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
AxumPath(session_id): AxumPath<String>,
) -> Result<String, StatusCode> {
authorize_daemon_request(&state, &headers)?;
let runtime = state
.session_runtime(&session_id)
.ok_or(StatusCode::NOT_FOUND)?;
let sidecar = sidecar_state_for_runtime(&runtime);
state
.governor
.execute("sidecar/repo-map", async move {
let handle = tokio::runtime::Handle::current();
tokio::task::spawn_blocking(move || {
handle.block_on(crate::sidecar::handlers::repo_map_handler(State(sidecar)))
})
.await
.unwrap_or(Err(StatusCode::INTERNAL_SERVER_ERROR))
})
.await
.map_err(|_| StatusCode::GATEWAY_TIMEOUT)?
}
async fn sidecar_prompt_context_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
AxumPath(session_id): AxumPath<String>,
Query(params): Query<crate::sidecar::handlers::PromptContextParams>,
) -> Result<String, StatusCode> {
authorize_daemon_request(&state, &headers)?;
let runtime = state
.session_runtime(&session_id)
.ok_or(StatusCode::NOT_FOUND)?;
let sidecar = sidecar_state_for_runtime(&runtime);
state
.governor
.execute("sidecar/prompt-context", async move {
let handle = tokio::runtime::Handle::current();
tokio::task::spawn_blocking(move || {
handle.block_on(crate::sidecar::handlers::prompt_context_handler(
State(sidecar),
Query(params),
))
})
.await
.unwrap_or(Err(StatusCode::INTERNAL_SERVER_ERROR))
})
.await
.map_err(|_| StatusCode::GATEWAY_TIMEOUT)?
}
async fn sidecar_stats_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
AxumPath(session_id): AxumPath<String>,
) -> Result<Json<crate::sidecar::StatsSnapshot>, StatusCode> {
authorize_daemon_request(&state, &headers)?;
let runtime = state
.session_runtime(&session_id)
.ok_or(StatusCode::NOT_FOUND)?;
let sidecar = sidecar_state_for_runtime(&runtime);
state
.governor
.execute("sidecar/stats", async move {
let handle = tokio::runtime::Handle::current();
tokio::task::spawn_blocking(move || {
handle.block_on(async {
Ok(crate::sidecar::handlers::stats_handler(State(sidecar)).await)
})
})
.await
.unwrap_or(Err(StatusCode::INTERNAL_SERVER_ERROR))
})
.await
.map_err(|_| StatusCode::GATEWAY_TIMEOUT)?
}
async fn heartbeat_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
AxumPath(session_id): AxumPath<String>,
) -> Result<Json<HeartbeatResponse>, StatusCode> {
authorize_daemon_request(&state, &headers)?;
Ok(Json(state.heartbeat(&session_id)))
}
async fn close_session_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
AxumPath(session_id): AxumPath<String>,
) -> Result<Json<CloseSessionResponse>, StatusCode> {
authorize_daemon_request(&state, &headers)?;
state
.close_session(&session_id)
.map(Json)
.ok_or(StatusCode::NOT_FOUND)
}
fn resolve_targets(
project: Option<&str>,
projects: Option<&[String]>,
active_project_id: &str,
) -> Result<Targets, String> {
match (project, projects) {
(Some(_), Some(_)) => Err(
"project and projects are mutually exclusive: pass exactly one (a single \
id in `project`, or a list/`[\"*\"]` in `projects`)."
.to_string(),
),
(Some(id), None) => {
let id = id.trim();
if id.is_empty() {
return Err("project must be a non-empty project id/alias.".to_string());
}
if id.contains('/') || id.contains('\\') {
return Err(format!(
"project must be a project id/alias, not a filesystem path ('{id}'). \
Open the folder first with index_folder(path=\"{id}\", add=true), \
then target it by its returned project id."
));
}
Ok(Targets::One(id.to_string()))
}
(None, Some(list)) => {
if list.is_empty() {
return Err(
"projects must not be empty: pass [\"*\"] for all open projects or an \
explicit list of project ids."
.to_string(),
);
}
let trimmed: Vec<&str> = list.iter().map(|id| id.trim()).collect();
if trimmed.iter().any(|id| id.is_empty()) {
return Err(
"projects entries must be non-empty project ids/aliases (blank entry found)."
.to_string(),
);
}
if trimmed.contains(&"*") {
return Ok(Targets::All);
}
for id in &trimmed {
if id.contains('/') || id.contains('\\') {
return Err(format!(
"projects entries must be project ids/aliases, not filesystem paths \
('{id}'). Open the folder first with \
index_folder(path=\"{id}\", add=true)."
));
}
}
let mut seen = std::collections::HashSet::new();
let deduped: Vec<String> = trimmed
.into_iter()
.filter(|id| seen.insert(id.to_string()))
.map(|id| id.to_string())
.collect();
Ok(Targets::Subset(deduped))
}
(None, None) => Ok(Targets::One(active_project_id.to_string())),
}
}
fn targets_is_single_active(targets: &Targets, active_project_id: &str) -> bool {
matches!(targets, Targets::One(id) if id == active_project_id)
}
fn targets_selects(targets: &Targets, project_id: &str) -> bool {
match targets {
Targets::One(id) => id == project_id,
Targets::Subset(ids) => ids.iter().any(|id| id == project_id),
Targets::All => true,
}
}
fn is_cross_project_read_verb(tool_name: &str) -> bool {
matches!(
tool_name,
"search_symbols" | "search_text" | "find_references"
)
}
fn resolve_cross_project_targets(
tool_name: &str,
params: &serde_json::Value,
active_project_id: &str,
) -> Option<Targets> {
if !is_cross_project_read_verb(tool_name) {
return None;
}
#[derive(serde::Deserialize)]
struct CrossProjectPeek {
#[serde(default)]
project: Option<String>,
#[serde(default)]
projects: Option<Vec<String>>,
}
let peek: CrossProjectPeek =
serde_json::from_value(params.clone()).unwrap_or(CrossProjectPeek {
project: None,
projects: None,
});
let targets = resolve_targets(
peek.project.as_deref(),
peek.projects.as_deref(),
active_project_id,
)
.ok()?;
if targets_is_single_active(&targets, active_project_id) {
None
} else {
Some(targets)
}
}
fn ensure_targets_open(targets: &Targets, working_set: &WorkingSet) -> Result<(), String> {
let missing: Vec<&String> = match targets {
Targets::One(id) => {
if working_set.get(id).is_none() {
vec![id]
} else {
Vec::new()
}
}
Targets::Subset(ids) => ids
.iter()
.filter(|id| working_set.get(id).is_none())
.collect(),
Targets::All => Vec::new(),
};
if missing.is_empty() {
Ok(())
} else {
Err(format!(
"project not open: {}. Open it in this session first with \
index_folder(path=..., add=true), then retarget.",
missing
.iter()
.map(|id| format!("'{id}'"))
.collect::<Vec<_>>()
.join(", ")
))
}
}
const CROSS_PROJECT_DEFAULT_RESULT_CAP: usize = 200;
const CROSS_PROJECT_MAX_RESULT_CAP: usize = 1000;
fn cross_project_result_cap(limit: Option<u32>) -> usize {
match limit {
Some(l) => (l as usize).clamp(1, CROSS_PROJECT_MAX_RESULT_CAP),
None => CROSS_PROJECT_DEFAULT_RESULT_CAP,
}
}
fn apply_cross_project_token_budget(body: String, max_tokens: Option<u64>) -> String {
let Some(max_tokens) = max_tokens.filter(|t| *t > 0) else {
return body;
};
let max_bytes = (max_tokens as usize).saturating_mul(4);
if max_bytes == 0 || body.len() <= max_bytes {
return body;
}
let cut_end = body
.bytes()
.enumerate()
.filter(|&(idx, b)| b == b'\n' && idx < max_bytes)
.map(|(idx, _)| idx + 1)
.next_back();
let mut truncated = match cut_end {
Some(end) => body[..end].to_string(),
None => String::new(),
};
truncated.push_str(&format!(
"... (truncated to fit max_tokens={max_tokens}; cross-project output is \
token-bounded — raise max_tokens or query a single project for the full set)\n"
));
truncated
}
fn reject_unsupported_cross_project_scoping(
tool_name: &str,
params: &serde_json::Value,
) -> anyhow::Result<()> {
fn refuse(param: &str) -> anyhow::Result<()> {
anyhow::bail!(
"{param} scoping is not supported with cross-project targeting; \
query a single project for scoped results."
);
}
#[derive(serde::Deserialize, Default)]
struct ScopePeek {
#[serde(default)]
path: Option<String>,
#[serde(default)]
symbol_kind: Option<String>,
#[serde(default)]
direction: Option<String>,
#[serde(default)]
structural: Option<bool>,
}
let peek: ScopePeek = serde_json::from_value(params.clone()).unwrap_or_default();
let present = |v: &Option<String>| v.as_deref().is_some_and(|s| !s.trim().is_empty());
match tool_name {
"search_text" => {
if peek.structural == Some(true) {
return refuse("structural");
}
}
"find_references" => {
if present(&peek.path) {
return refuse("path");
}
if present(&peek.symbol_kind) {
return refuse("symbol_kind");
}
if present(&peek.direction) {
return refuse("direction");
}
}
_ => {}
}
Ok(())
}
fn execute_cross_project_read(
tool_name: &str,
params: serde_json::Value,
targets: Targets,
working_set: &WorkingSet,
) -> anyhow::Result<String> {
ensure_targets_open(&targets, working_set).map_err(|message| anyhow::anyhow!("{message}"))?;
reject_unsupported_cross_project_scoping(tool_name, ¶ms)?;
let multi = match &targets {
Targets::One(_) => false,
Targets::Subset(ids) => ids.len() > 1,
Targets::All => working_set.len() > 1,
};
match tool_name {
"search_symbols" => {
let input: SearchSymbolsInput = decode_params(params)?;
let query = input.query.as_deref().unwrap_or("").trim();
if query.is_empty() {
anyhow::bail!(
"cross-project search_symbols requires a non-empty query \
(browse mode is single-project only)."
);
}
let options = search_symbols_options_from_input(&input)
.map_err(|message| anyhow::anyhow!(message))?;
let cap = cross_project_result_cap(input.limit);
let hits = working_set.search_symbols(&targets, query, input.kind.as_deref(), &options);
let body = format_cross_project_symbols(&hits, query, multi, cap);
Ok(apply_cross_project_token_budget(body, input.max_tokens))
}
"search_text" => {
let input: SearchTextInput = decode_params(params)?;
let regex = input.regex.unwrap_or(false);
let mut options = search_text_options_from_input(&input)
.map_err(|message| anyhow::anyhow!(message))?;
options.context = None;
let cap = cross_project_result_cap(input.limit);
let results = working_set
.search_text(
&targets,
input.query.as_deref(),
input.terms.as_deref(),
regex,
&options,
)
.map_err(|error| anyhow::anyhow!("text search failed: {error:?}"))?;
let body = format_cross_project_text(&results, multi, cap);
Ok(apply_cross_project_token_budget(body, input.max_tokens))
}
"find_references" => {
let input: FindReferencesInput = decode_params(params)?;
let name = input.name.trim();
if name.is_empty() {
anyhow::bail!("cross-project find_references requires a non-empty name.");
}
let kind_filter = match input.kind.as_deref() {
Some("call") => Some(crate::domain::ReferenceKind::Call),
Some("import") => Some(crate::domain::ReferenceKind::Import),
Some("type_usage") => Some(crate::domain::ReferenceKind::TypeUsage),
Some("macro_use") => Some(crate::domain::ReferenceKind::MacroUse),
Some("value_use") => Some(crate::domain::ReferenceKind::ValueUse),
_ => None,
};
let cap = cross_project_result_cap(input.limit);
let hits = working_set.find_references(&targets, name, kind_filter, false);
let body = format_cross_project_references(&hits, name, multi, cap);
Ok(apply_cross_project_token_budget(body, input.max_tokens))
}
other => anyhow::bail!("'{other}' is not a cross-project read verb"),
}
}
fn format_cross_project_symbols(
hits: &[crate::live_index::view::ProjectHit<crate::live_index::view::ViewSymbolHit>],
query: &str,
multi: bool,
cap: usize,
) -> String {
if hits.is_empty() {
return format!("No symbols matching '{query}' in the targeted project(s).");
}
let total = hits.len();
let shown = total.min(cap);
let mut out = String::new();
let mut current: Option<&str> = None;
if shown < total {
out.push_str(&format!(
"{shown} of {total} matches across projects (truncated; cross-project results \
are capped — pass a larger `limit` or query a single project for the full set)\n"
));
} else {
out.push_str(&format!("{total} matches across projects\n"));
}
for ph in hits.iter().take(shown) {
if multi && current != Some(ph.project_id.as_str()) {
current = Some(ph.project_id.as_str());
out.push_str(&format!(
"\n\u{2500}\u{2500} project: {} \u{2500}\u{2500}\n",
ph.project_id
));
}
let h = &ph.hit;
out.push_str(&format!(
" {}: {} {} ({})\n",
h.line, h.kind, h.name, h.path
));
}
out
}
fn format_cross_project_text(
results: &[crate::live_index::view::ProjectHit<crate::live_index::search::TextSearchResult>],
multi: bool,
cap: usize,
) -> String {
let total: usize = results.iter().map(|ph| ph.hit.total_matches).sum();
if total == 0 {
return "No text matches in the targeted project(s).".to_string();
}
let mut body = String::new();
let mut shown = 0usize;
'projects: for ph in results {
if ph.hit.files.is_empty() {
continue;
}
let mut header_written = false;
for file in &ph.hit.files {
if file.matches.is_empty() {
continue;
}
if shown >= cap {
break 'projects;
}
if multi && !header_written {
body.push_str(&format!(
"\n\u{2500}\u{2500} project: {} \u{2500}\u{2500}\n",
ph.project_id
));
header_written = true;
}
body.push_str(&format!("{}\n", file.path));
for m in &file.matches {
if shown >= cap {
break 'projects;
}
body.push_str(&format!(" {}: {}\n", m.line_number, m.line));
shown += 1;
}
}
}
let mut out = String::new();
if shown < total {
out.push_str(&format!(
"{shown} of {total} text matches across projects (truncated; cross-project results \
are capped — pass a larger `limit` or query a single project for the full set)\n"
));
} else {
out.push_str(&format!("{total} text matches across projects\n"));
}
out.push_str(&body);
out
}
fn format_cross_project_references(
hits: &[crate::live_index::view::ProjectHit<(String, crate::domain::ReferenceRecord)>],
name: &str,
multi: bool,
cap: usize,
) -> String {
if hits.is_empty() {
return format!("No references to '{name}' in the targeted project(s).");
}
let total = hits.len();
let shown = total.min(cap);
let mut out = String::new();
let mut current: Option<&str> = None;
if shown < total {
out.push_str(&format!(
"{shown} of {total} references across projects (truncated; cross-project results \
are capped — pass a larger `limit` or query a single project for the full set)\n"
));
} else {
out.push_str(&format!("{total} references across projects\n"));
}
for ph in hits.iter().take(shown) {
if multi && current != Some(ph.project_id.as_str()) {
current = Some(ph.project_id.as_str());
out.push_str(&format!(
"\n\u{2500}\u{2500} project: {} \u{2500}\u{2500}\n",
ph.project_id
));
}
let (path, reference) = &ph.hit;
out.push_str(&format!(
" {}:{} [{:?}] {}\n",
path,
reference.line_range.0 + 1,
reference.kind,
reference.name
));
}
out
}
fn strip_cross_project_targeting(mut params: serde_json::Value) -> serde_json::Value {
if let serde_json::Value::Object(ref mut object) = params {
object.remove("project");
object.remove("projects");
}
params
}
async fn execute_tool_call(
runtime: SessionRuntime,
tool_name: &str,
mut params: serde_json::Value,
) -> anyhow::Result<String> {
runtime.token_stats.record_tool_call(tool_name);
if is_cross_project_read_verb(tool_name) {
#[derive(serde::Deserialize)]
struct CrossProjectPeek {
#[serde(default)]
project: Option<String>,
#[serde(default)]
projects: Option<Vec<String>>,
}
let peek: CrossProjectPeek =
serde_json::from_value(params.clone()).unwrap_or(CrossProjectPeek {
project: None,
projects: None,
});
let targets = resolve_targets(
peek.project.as_deref(),
peek.projects.as_deref(),
&runtime.project_id,
)
.map_err(|message| anyhow::anyhow!("{message}"))?;
if !targets_is_single_active(&targets, &runtime.project_id) {
let working_set = runtime.working_set.read();
return execute_cross_project_read(tool_name, params, targets, &working_set);
}
params = strip_cross_project_targeting(params);
}
let server = runtime.server;
match tool_name {
"get_symbol" => Ok(server
.get_symbol(Parameters(decode_params::<GetSymbolInput>(params)?))
.await),
"get_repo_map" => Ok(server
.get_repo_map(Parameters(decode_params::<GetRepoMapInput>(params)?))
.await),
"get_file_context" => Ok(server
.get_file_context(Parameters(decode_params::<GetFileContextInput>(params)?))
.await),
"get_symbol_context" => Ok(server
.get_symbol_context(Parameters(decode_params::<GetSymbolContextInput>(params)?))
.await),
"analyze_file_impact" => Ok(server
.analyze_file_impact(Parameters(decode_params::<AnalyzeFileImpactInput>(params)?))
.await),
"search_symbols" => Ok(server
.search_symbols(Parameters(decode_params::<SearchSymbolsInput>(params)?))
.await),
"search_text" => Ok(server
.search_text(Parameters(decode_params::<SearchTextInput>(params)?))
.await),
"trace_symbol" => {
let tp: TraceSymbolInput = decode_params(params)?;
let sections = tp.sections.unwrap_or_default();
let output = server
.get_symbol_context(Parameters(GetSymbolContextInput {
name: tp.name,
file: None,
path: Some(tp.path),
symbol_kind: tp.kind,
symbol_line: tp.symbol_line,
verbosity: tp.verbosity,
bundle: None,
sections: Some(sections),
max_tokens: None,
estimate: None,
}))
.await;
Ok(format!("{TRACE_SYMBOL_ALIAS_DEPRECATION}\n\n{output}"))
}
"inspect_match" => Ok(server
.inspect_match(Parameters(decode_params::<InspectMatchInput>(params)?))
.await),
"search_files" => Ok(server
.search_files(Parameters(decode_params::<SearchFilesInput>(params)?))
.await),
"health" => {
let input: HealthInput = decode_params(params)?;
Ok(server.health_for_daemon_session(
runtime.project_id.clone(),
runtime.session_id.clone(),
runtime.canonical_root.clone(),
crate::protocol::format::QuarantineWindow::from_args(
input.quarantine_offset.map(|n| n as usize),
input.quarantine_limit.map(|n| n as usize),
),
))
}
"health_compact" => Ok(server.health_compact_for_daemon_session(
runtime.project_id.clone(),
runtime.session_id.clone(),
runtime.canonical_root.clone(),
)),
"index_folder" => Ok(server
.index_folder(Parameters(decode_params::<IndexFolderInput>(params)?))
.await),
"what_changed" => Ok(server
.what_changed(Parameters(decode_params::<WhatChangedInput>(params)?))
.await),
"get_file_content" => Ok(server
.get_file_content(Parameters(decode_params::<GetFileContentInput>(params)?))
.await),
"find_references" => Ok(server
.find_references(Parameters(decode_params::<FindReferencesInput>(params)?))
.await),
"find_dependents" => Ok(server
.find_dependents(Parameters(decode_params::<FindDependentsInput>(params)?))
.await),
"explore" => Ok(server
.explore(Parameters(decode_params::<ExploreInput>(params)?))
.await),
"diff_symbols" => Ok(server
.diff_symbols(Parameters(decode_params::<DiffSymbolsInput>(params)?))
.await),
"replace_symbol_body" => Ok(server
.replace_symbol_body(Parameters(decode_params::<ReplaceSymbolBodyInput>(params)?))
.await),
"insert_symbol" => Ok(server
.insert_symbol(Parameters(decode_params::<InsertSymbolInput>(params)?))
.await),
"delete_symbol" => Ok(server
.delete_symbol(Parameters(decode_params::<DeleteSymbolInput>(params)?))
.await),
"edit_within_symbol" => Ok(server
.edit_within_symbol(Parameters(decode_params::<EditWithinSymbolInput>(params)?))
.await),
"batch_edit" => Ok(server
.batch_edit(Parameters(decode_params::<BatchEditInput>(params)?))
.await),
"batch_rename" => Ok(server
.batch_rename(Parameters(decode_params::<BatchRenameInput>(params)?))
.await),
"batch_insert" => Ok(server
.batch_insert(Parameters(decode_params::<BatchInsertInput>(params)?))
.await),
"validate_file_syntax" => Ok(server
.validate_file_syntax(Parameters(decode_params::<ValidateFileSyntaxInput>(
params,
)?))
.await),
"conventions" => Ok(server.conventions().await),
"edit_plan" => Ok(server
.edit_plan(Parameters(decode_params::<EditPlanInput>(params)?))
.await),
"investigation_suggest" => Ok(server
.investigation_suggest(Parameters(decode_params::<InvestigationInput>(params)?))
.await),
"context_inventory" => Ok(server.context_inventory().await),
"symforge_retrieve" => Ok(server
.symforge_retrieve(Parameters(decode_params::<SymforgeRetrieveInput>(params)?))
.await),
"ask" => Ok(server
.ask(Parameters(decode_params::<SmartQueryInput>(params)?))
.await),
"checkpoint_now" => Ok(server
.checkpoint_now(Parameters(decode_params::<CheckpointNowInput>(params)?))
.await),
"detect_impact" => Ok(server
.detect_impact(Parameters(decode_params::<DetectImpactInput>(params)?))
.await),
"detect_changes" => {
let output = server
.detect_impact(Parameters(decode_params::<DetectImpactInput>(params)?))
.await;
Ok(format!("{DETECT_CHANGES_ALIAS_DEPRECATION}\n\n{output}"))
}
"status" => Ok(server
.status_for_daemon_session(&decode_params::<crate::stel::StelStatusRequest>(params)?)),
other => anyhow::bail!("unknown tool '{other}'"),
}
}
fn sidecar_state_for_runtime(runtime: &SessionRuntime) -> SidecarState {
SidecarState {
index: Arc::clone(&runtime.index),
token_stats: Arc::clone(&runtime.token_stats),
repo_root: Some(runtime.canonical_root.clone()),
symbol_cache: Arc::clone(&runtime.symbol_cache),
}
}
fn decode_params<T>(params: serde_json::Value) -> anyhow::Result<T>
where
T: serde::de::DeserializeOwned,
{
serde_json::from_value(params).context("invalid tool parameters")
}
fn bad_request(error: anyhow::Error) -> (axum::http::StatusCode, String) {
(axum::http::StatusCode::BAD_REQUEST, error.to_string())
}
fn internal_error(error: tokio::task::JoinError) -> (axum::http::StatusCode, String) {
(
axum::http::StatusCode::INTERNAL_SERVER_ERROR,
error.to_string(),
)
}
fn canonical_project_root(root: &Path) -> anyhow::Result<PathBuf> {
root.canonicalize()
.with_context(|| format!("failed to canonicalize project root {}", root.display()))
}
fn project_key(root: &Path) -> String {
let normalized = normalized_path_string(root);
let stable_path = if cfg!(windows) {
normalized.to_lowercase()
} else {
normalized
};
format!(
"project-{}",
crate::hash::digest_hex(stable_path.as_bytes())
)
}
fn normalized_path_string(path: &Path) -> String {
path.to_string_lossy().replace('\\', "/")
}
pub(crate) fn daemon_dir() -> io::Result<PathBuf> {
if let Some(explicit_home) = std::env::var_os("SYMFORGE_HOME") {
let dir = PathBuf::from(explicit_home);
std::fs::create_dir_all(&dir)?;
return Ok(dir);
}
let home = dirs::home_dir()
.ok_or_else(|| io::Error::new(io::ErrorKind::NotFound, "home directory not found"))?;
paths::ensure_symforge_dir(&home)
}
fn write_daemon_port_file(port: u16) -> io::Result<()> {
let path = daemon_dir()?.join(daemon_port_file_name());
std::fs::write(&path, port.to_string()).map_err(|e| {
io::Error::new(
e.kind(),
format!("writing daemon port file at {}: {}", path.display(), e),
)
})
}
fn write_daemon_pid_file(pid: u32) -> io::Result<()> {
let path = daemon_dir()?.join(daemon_pid_file_name());
std::fs::write(&path, pid.to_string()).map_err(|e| {
io::Error::new(
e.kind(),
format!("writing daemon pid file at {}: {}", path.display(), e),
)
})
}
fn read_daemon_pid_file() -> io::Result<u32> {
let contents = read_daemon_runtime(
&daemon_dir()?,
&daemon_pid_file_name(),
LEGACY_DAEMON_PID_FILE,
)?;
contents
.trim()
.parse::<u32>()
.map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))
}
pub(crate) fn read_daemon_port_file() -> io::Result<u16> {
let contents = read_daemon_runtime(
&daemon_dir()?,
&daemon_port_file_name(),
LEGACY_DAEMON_PORT_FILE,
)?;
contents
.trim()
.parse::<u16>()
.map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))
}
#[cfg(test)]
fn cleanup_daemon_files() {
cleanup_daemon_runtime_files();
if let Ok(dir) = daemon_dir() {
let _ = std::fs::remove_file(dir.join(daemon_start_lock_file_name()));
let _ = std::fs::remove_file(dir.join(LEGACY_DAEMON_START_LOCK_FILE));
}
}
fn cleanup_daemon_runtime_files() {
if let Ok(dir) = daemon_dir() {
let _ = std::fs::remove_file(dir.join(daemon_port_file_name()));
let _ = std::fs::remove_file(dir.join(daemon_pid_file_name()));
let _ = std::fs::remove_file(dir.join(daemon_token_file_name()));
let _ = std::fs::remove_file(dir.join(LEGACY_DAEMON_PORT_FILE));
let _ = std::fs::remove_file(dir.join(LEGACY_DAEMON_PID_FILE));
}
}
#[allow(unsafe_code)] pub(crate) fn terminate_process(pid: u32) -> io::Result<()> {
#[cfg(windows)]
{
let status = crate::process_util::hidden_command("taskkill")
.args(["/PID", &pid.to_string(), "/T", "/F"])
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null())
.status()?;
if status.success() || status.code() == Some(128) {
Ok(())
} else {
Err(io::Error::other(format!(
"taskkill exited with status {status}"
)))
}
}
#[cfg(not(windows))]
{
let result = unsafe { libc::kill(pid as i32, libc::SIGTERM) };
if result == 0 {
for _ in 0..10 {
std::thread::sleep(std::time::Duration::from_millis(100));
if unsafe { libc::kill(pid as i32, 0) } != 0 {
return Ok(());
}
}
Ok(()) } else {
let errno = std::io::Error::last_os_error();
if errno.raw_os_error() == Some(libc::ESRCH) {
Ok(()) } else {
Err(errno)
}
}
}
}
fn unix_seconds(time: SystemTime) -> u64 {
time.duration_since(SystemTime::UNIX_EPOCH)
.unwrap_or_default()
.as_secs()
}
#[cfg(test)]
mod tests {
use super::*;
use std::ffi::OsString;
use std::path::{Path, PathBuf};
use std::time::Duration;
use once_cell::sync::Lazy;
use tempfile::TempDir;
use tokio::sync::{Mutex, MutexGuard};
static ENV_LOCK: Lazy<Mutex<()>> = Lazy::new(|| Mutex::new(()));
fn project_dir(name: &str) -> TempDir {
let dir = TempDir::with_prefix(name).expect("temp dir");
std::fs::create_dir_all(dir.path().join("src")).expect("src dir");
dir
}
async fn env_lock() -> MutexGuard<'static, ()> {
ENV_LOCK.lock().await
}
fn authed_client(handle: &DaemonHandle) -> reqwest::Client {
let token = handle.state.auth_token.clone();
let mut headers = header::HeaderMap::new();
let mut value =
header::HeaderValue::from_str(&format!("Bearer {token}")).expect("valid bearer header");
value.set_sensitive(true);
headers.insert(header::AUTHORIZATION, value);
reqwest::Client::builder()
.default_headers(headers)
.build()
.expect("build authed reqwest client")
}
#[test]
fn project_instance_load_consumes_exported_team_artifact() {
let tmp = TempDir::new().expect("tempdir");
std::fs::write(tmp.path().join("main.rs"), b"fn main() { helper(); }\n").unwrap();
std::fs::write(tmp.path().join("helper.rs"), b"pub fn helper() {}\n").unwrap();
let fresh = live_index::LiveIndex::load(tmp.path()).expect("cold load");
{
let guard = fresh.read();
live_index::persist::export_artifact(&guard, tmp.path()).expect("export artifact");
}
assert!(
!tmp.path().join(".symforge").join("index.bin").exists(),
"only the .zst team artifact should exist for the clone scenario"
);
assert!(
tmp.path().join(".symforge").join("index.bin.zst").exists(),
"the exported team artifact must be present"
);
let project = ProjectInstance::load(tmp.path()).expect("project load");
let guard = project.index.read();
assert_eq!(
guard.load_source(),
crate::live_index::store::IndexLoadSource::SnapshotRestore,
"daemon bootstrap must consume the team artifact (SnapshotRestore), \
not fall back to a cold full scan (FreshLoad)"
);
assert!(
guard.get_file("main.rs").is_some(),
"the artifact-restored index must serve the indexed files"
);
}
#[test]
fn constant_time_eq_accepts_equal_and_rejects_unequal() {
assert!(constant_time_eq(b"sekret-token", b"sekret-token"));
assert!(constant_time_eq(b"", b""));
assert!(!constant_time_eq(b"short", b"longer-token"));
assert!(!constant_time_eq(b"longer-token", b"short"));
assert!(!constant_time_eq(b"sekret-token", b"sekret-tokeX"));
assert!(!constant_time_eq(b"sekret-token", b"Xekret-token"));
}
#[test]
fn constant_time_eq_has_no_early_out_on_first_mismatch() {
let base = vec![0u8; 64];
let mut differ_first = base.clone();
differ_first[0] = 1;
assert!(!constant_time_eq(&base, &differ_first));
let mut differ_last = base.clone();
differ_last[63] = 1;
assert!(!constant_time_eq(&base, &differ_last));
assert!(constant_time_eq(&base, &base.clone()));
}
#[test]
fn connection_surface_header_resolves_profile_and_ignores_junk() {
use crate::protocol::surface_probe::{CONNECTION_SURFACE_HEADER, SurfaceProfile};
let mut headers = HeaderMap::new();
assert_eq!(connection_surface_from_headers(&headers), None);
headers.insert(CONNECTION_SURFACE_HEADER, "compact".parse().unwrap());
assert_eq!(
connection_surface_from_headers(&headers),
Some(SurfaceProfile::Compact)
);
headers.insert(CONNECTION_SURFACE_HEADER, "full".parse().unwrap());
assert_eq!(
connection_surface_from_headers(&headers),
Some(SurfaceProfile::Full)
);
headers.insert(CONNECTION_SURFACE_HEADER, "garbage".parse().unwrap());
assert_eq!(connection_surface_from_headers(&headers), None);
}
#[test]
fn authorize_daemon_request_constant_time_token_check() {
fn state_with_token(token: &str) -> DaemonState {
DaemonState::with_token(token.to_string())
}
fn bearer_headers(value: &str) -> HeaderMap {
let mut headers = HeaderMap::new();
headers.insert(
header::AUTHORIZATION,
header::HeaderValue::from_str(value).expect("valid header value"),
);
headers
}
let state = state_with_token("the-real-token-value");
assert!(
authorize_daemon_request(&state, &bearer_headers("Bearer the-real-token-value"))
.is_ok()
);
assert_eq!(
authorize_daemon_request(&state, &bearer_headers("Bearer the-real-token-WRONG")),
Err(StatusCode::UNAUTHORIZED)
);
assert_eq!(
authorize_daemon_request(&state, &bearer_headers("Bearer ")),
Err(StatusCode::UNAUTHORIZED)
);
assert_eq!(
authorize_daemon_request(&state, &HeaderMap::new()),
Err(StatusCode::UNAUTHORIZED)
);
assert_eq!(
authorize_daemon_request(&state, &bearer_headers("Basic the-real-token-value")),
Err(StatusCode::UNAUTHORIZED)
);
}
async fn wait_for_path_absent(path: &Path) {
let deadline = tokio::time::Instant::now() + Duration::from_secs(2);
while path.exists() {
if tokio::time::Instant::now() >= deadline {
break;
}
tokio::time::sleep(Duration::from_millis(25)).await;
}
}
async fn spawn_fake_health_server(
health: DaemonHealth,
) -> (u16, tokio::sync::oneshot::Sender<()>) {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind fake daemon");
let port = listener.local_addr().expect("listener addr").port();
let app = Router::new().route(
"/health",
get({
let health = health.clone();
move || {
let health = health.clone();
async move { Json(health) }
}
}),
);
let (shutdown_tx, shutdown_rx) = tokio::sync::oneshot::channel();
tokio::spawn(async move {
let shutdown = async move {
let _ = shutdown_rx.await;
};
let _ = axum::serve(listener, app)
.with_graceful_shutdown(shutdown)
.await;
});
(port, shutdown_tx)
}
struct EnvVarGuard {
key: &'static str,
previous: Option<OsString>,
}
#[allow(unsafe_code)] impl EnvVarGuard {
fn set(key: &'static str, value: &std::path::Path) -> Self {
let previous = std::env::var_os(key);
unsafe {
std::env::set_var(key, value);
}
Self { key, previous }
}
fn set_str(key: &'static str, value: &str) -> Self {
let previous = std::env::var_os(key);
unsafe {
std::env::set_var(key, value);
}
Self { key, previous }
}
fn unset(key: &'static str) -> Self {
let previous = std::env::var_os(key);
unsafe {
std::env::remove_var(key);
}
Self { key, previous }
}
}
#[allow(unsafe_code)] impl Drop for EnvVarGuard {
fn drop(&mut self) {
match &self.previous {
Some(previous) => unsafe {
std::env::set_var(self.key, previous);
},
None => unsafe {
std::env::remove_var(self.key);
},
}
}
}
struct CwdGuard {
previous: PathBuf,
}
impl CwdGuard {
fn set(path: &Path) -> Self {
let previous = std::env::current_dir().expect("current dir");
std::env::set_current_dir(path).expect("set current dir");
Self { previous }
}
}
impl Drop for CwdGuard {
fn drop(&mut self) {
if std::env::set_current_dir(&self.previous).is_err() {
std::env::set_current_dir(env!("CARGO_MANIFEST_DIR"))
.expect("manifest dir must be a valid cwd fallback");
}
}
}
#[tokio::test]
async fn test_daemon_bind_policy_rejects_non_loopback_without_opt_in() {
let _env_lock = env_lock().await;
let _bind_guard = EnvVarGuard::set_str(DAEMON_BIND_ENV, "0.0.0.0");
let _allow_guard = EnvVarGuard::unset(DAEMON_ALLOW_NON_LOOPBACK_ENV);
let error = resolve_daemon_bind_host("127.0.0.1")
.expect_err("non-loopback bind must require explicit opt-in");
let message = error.to_string();
assert!(
message.contains("refusing non-loopback daemon bind"),
"unexpected bind rejection: {message}"
);
assert!(
message.contains(DAEMON_ALLOW_NON_LOOPBACK_ENV),
"rejection should name the explicit opt-in env var: {message}"
);
}
#[tokio::test]
async fn test_daemon_bind_policy_allows_non_loopback_with_explicit_opt_in() {
let _env_lock = env_lock().await;
let _bind_guard = EnvVarGuard::set_str(DAEMON_BIND_ENV, "0.0.0.0");
let _allow_guard = EnvVarGuard::set_str(DAEMON_ALLOW_NON_LOOPBACK_ENV, "1");
let resolved = resolve_daemon_bind_host("127.0.0.1")
.expect("explicit opt-in should allow non-loopback bind");
assert_eq!(resolved, "0.0.0.0");
}
#[test]
fn test_open_same_root_reuses_project_instance() {
let project = project_dir("symforge-daemon-a");
let state = DaemonState::new();
let first = state
.open_project_session(OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "claude".to_string(),
pid: Some(100),
})
.expect("first session");
let second = state
.open_project_session(OpenProjectRequest {
project_root: project.path().join(".").display().to_string(),
client_name: "codex".to_string(),
pid: Some(200),
})
.expect("second session");
assert_eq!(first.project_id, second.project_id);
assert_ne!(first.session_id, second.session_id);
let projects = state.list_projects();
assert_eq!(projects.len(), 1);
assert_eq!(projects[0].session_count, 2);
}
#[test]
fn test_open_distinct_roots_creates_distinct_projects() {
let project_a = project_dir("symforge-daemon-b");
let project_b = project_dir("symforge-daemon-c");
let state = DaemonState::new();
let first = state
.open_project_session(OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "claude".to_string(),
pid: None,
})
.expect("first project");
let second = state
.open_project_session(OpenProjectRequest {
project_root: project_b.path().display().to_string(),
client_name: "codex".to_string(),
pid: None,
})
.expect("second project");
assert_ne!(first.project_id, second.project_id);
assert_eq!(state.list_projects().len(), 2);
assert_eq!(state.health().session_count, 2);
}
fn session_seeded_base(state: &DaemonState, session_id: &str) -> Arc<IndexBase> {
let sessions = state.sessions.read();
let session = sessions.get(session_id).expect("session present");
let working_set = session.working_set.read();
assert_eq!(
working_set.len(),
1,
"Phase 1 seeds exactly one working-set entry"
);
let entry = working_set
.get(&session.active_project_id)
.expect("seeded entry for the active project");
Arc::clone(&entry.base)
}
#[test]
fn test_open_same_root_twice_shares_interned_base() {
let project = project_dir("symforge-daemon-base-intern");
let state = DaemonState::new();
let first = state
.open_project_session(OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "claude".to_string(),
pid: Some(11),
})
.expect("first session");
let second = state
.open_project_session(OpenProjectRequest {
project_root: project.path().join(".").display().to_string(),
client_name: "codex".to_string(),
pid: Some(22),
})
.expect("second session");
assert_eq!(
first.project_id, second.project_id,
"same canonical root -> same project"
);
let base_first = session_seeded_base(&state, &first.session_id);
let base_second = session_seeded_base(&state, &second.session_id);
assert!(
Arc::ptr_eq(&base_first, &base_second),
"two sessions on the same (root, commit) must share one Arc<IndexBase>"
);
assert_eq!(
state.bases.read().len(),
1,
"one canonical root -> one interned base"
);
}
#[test]
fn test_open_distinct_roots_intern_distinct_bases() {
let project_a = project_dir("symforge-daemon-base-distinct-a");
let project_b = project_dir("symforge-daemon-base-distinct-b");
let state = DaemonState::new();
let first = state
.open_project_session(OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "claude".to_string(),
pid: None,
})
.expect("project a session");
let second = state
.open_project_session(OpenProjectRequest {
project_root: project_b.path().display().to_string(),
client_name: "codex".to_string(),
pid: None,
})
.expect("project b session");
let base_a = session_seeded_base(&state, &first.session_id);
let base_b = session_seeded_base(&state, &second.session_id);
assert!(
!Arc::ptr_eq(&base_a, &base_b),
"distinct roots must NOT share a base"
);
assert_ne!(
base_a.key, base_b.key,
"distinct roots -> distinct BaseKeys"
);
assert_eq!(
state.bases.read().len(),
2,
"two roots -> two interned bases"
);
}
#[test]
fn test_gc_orphaned_bases_evicts_orphan_keeps_live() {
use crate::live_index::store::LiveIndex;
use crate::live_index::view::{CommitId, WorkingSet};
let state = DaemonState::new();
let root = "/synthetic/gc-root";
let orphan_key = BaseKey::new(root, CommitId::Sha("old-commit".to_string()));
state.bases.write().insert(
orphan_key.clone(),
Arc::new(IndexBase::new(
orphan_key.clone(),
Arc::new(LiveIndex::empty_live_index()),
1,
)),
);
let live_key = BaseKey::new(root, CommitId::Sha("new-commit".to_string()));
let live_base = Arc::new(IndexBase::new(
live_key.clone(),
Arc::new(LiveIndex::empty_live_index()),
2,
));
state
.bases
.write()
.insert(live_key.clone(), Arc::clone(&live_base));
let working_set = Arc::new(RwLock::new(WorkingSet::new()));
working_set.write().add("proj", Arc::clone(&live_base));
drop(live_base);
{
let bases = state.bases.read();
assert!(
bases.contains_key(&orphan_key),
"precondition: orphan must be present before GC (proves the leak)"
);
assert_eq!(bases.len(), 2, "precondition: both bases interned");
assert_eq!(
Arc::strong_count(bases.get(&orphan_key).unwrap()),
1,
"orphan must be map-only (the eviction signal)"
);
assert_eq!(
Arc::strong_count(bases.get(&live_key).unwrap()),
2,
"live base is held by map + working-set entry"
);
}
state.gc_orphaned_bases();
let bases = state.bases.read();
assert!(
!bases.contains_key(&orphan_key),
"GC must evict the orphaned (map-only) base"
);
assert!(
bases.contains_key(&live_key),
"GC must NOT evict a base a live working set still references"
);
assert_eq!(bases.len(), 1, "only the orphan is removed");
let table_live = bases.get(&live_key).unwrap();
let ws = working_set.read();
let entry = ws.get("proj").expect("live entry present");
assert!(
Arc::ptr_eq(table_live, &entry.base),
"SC-002: survivor is the same shared Arc the working set holds"
);
}
#[test]
fn test_close_last_session_gcs_orphaned_base() {
let project = project_dir("symforge-daemon-close-gc");
let state = DaemonState::new();
let opened = state
.open_project_session(OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "claude".to_string(),
pid: None,
})
.expect("session");
assert_eq!(
state.bases.read().len(),
1,
"open interns one base for the root"
);
state
.close_session(&opened.session_id)
.expect("close the only session");
assert_eq!(
state.bases.read().len(),
0,
"close_session must GC the base no session references anymore"
);
}
#[test]
fn test_resolve_targets_contract() {
let active = "project-active";
assert_eq!(
resolve_targets(None, None, active).unwrap(),
Targets::One(active.to_string())
);
assert_eq!(
resolve_targets(Some(active), None, active).unwrap(),
Targets::One(active.to_string())
);
assert_eq!(
resolve_targets(Some("project-other"), None, active).unwrap(),
Targets::One("project-other".to_string())
);
assert_eq!(
resolve_targets(None, Some(&["*".to_string()]), active).unwrap(),
Targets::All
);
assert_eq!(
resolve_targets(
None,
Some(&["project-a".to_string(), "project-b".to_string()]),
active
)
.unwrap(),
Targets::Subset(vec!["project-a".to_string(), "project-b".to_string()])
);
assert!(
resolve_targets(Some("project-a"), Some(&["project-b".to_string()]), active).is_err()
);
assert!(resolve_targets(None, Some(&[]), active).is_err());
let err = resolve_targets(Some("E:/project/symforge"), None, active).unwrap_err();
assert!(
err.contains("index_folder") && err.contains("add"),
"path-in-project error must point at index_folder(add:true): {err}"
);
assert!(resolve_targets(Some("/abs/path"), None, active).is_err());
assert!(resolve_targets(None, Some(&["src/lib.rs".to_string()]), active).is_err());
assert!(resolve_targets(Some(" "), None, active).is_err());
}
#[test]
fn test_targets_is_single_active() {
let active = "project-active";
assert!(targets_is_single_active(
&Targets::One(active.to_string()),
active
));
assert!(!targets_is_single_active(
&Targets::One("project-other".to_string()),
active
));
assert!(!targets_is_single_active(&Targets::All, active));
assert!(!targets_is_single_active(
&Targets::Subset(vec![active.to_string()]),
active
));
}
#[test]
fn test_set_active_and_remove_project_management() {
let project_a = project_dir("symforge-mgmt-a");
let project_b = project_dir("symforge-mgmt-b");
std::fs::write(project_b.path().join("src").join("b.rs"), "fn b() {}\n")
.expect("write source b");
let state = DaemonState::new();
let opened = state
.open_project_session(OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "mgmt".to_string(),
pid: None,
})
.expect("open A");
let active_a = opened.project_id.clone();
state
.index_folder_for_session(
&opened.session_id,
IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: None,
add: Some(true),
},
)
.expect("additive open B");
let project_b_id =
project_key(&canonical_project_root(project_b.path()).expect("canonical b"));
{
let sessions = state.sessions.read();
let session = sessions.get(&opened.session_id).expect("session");
let ws = session.working_set.read();
assert_eq!(ws.len(), 2, "working set holds A and B");
assert_eq!(session.active_project_id, active_a, "A still active");
assert!(ws.get(&active_a).is_some());
assert!(ws.get(&project_b_id).is_some());
}
assert!(
!state.set_active_project(&opened.session_id, "project-not-open"),
"activating a non-open project must fail"
);
assert!(
state.set_active_project(&opened.session_id, &project_b_id),
"activating an open project must succeed"
);
assert_eq!(
state
.sessions
.read()
.get(&opened.session_id)
.unwrap()
.active_project_id,
project_b_id,
"B is now active"
);
assert!(
!state.remove_project_from_session(&opened.session_id, &project_b_id),
"removing the active project must be refused"
);
assert!(
state.remove_project_from_session(&opened.session_id, &active_a),
"removing a non-active open project must succeed"
);
{
let sessions = state.sessions.read();
let ws = sessions.get(&opened.session_id).unwrap().working_set.read();
assert_eq!(ws.len(), 1, "only B remains");
assert!(ws.get(&active_a).is_none(), "A removed");
assert!(ws.get(&project_b_id).is_some(), "B remains");
}
assert!(
!state
.list_projects()
.iter()
.any(|p| p.project_id == active_a),
"project A removed after its last session reference dropped"
);
let _ = state.close_session(&opened.session_id);
}
#[test]
fn test_index_folder_additive_keeps_active_and_adds_to_working_set() {
let project_a = project_dir("symforge-additive-a");
let project_b = project_dir("symforge-additive-b");
std::fs::write(project_b.path().join("src").join("b.rs"), "fn b() {}\n")
.expect("write source b");
let state = DaemonState::new();
let opened = state
.open_project_session(OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "additive".to_string(),
pid: None,
})
.expect("open A");
let active_a = opened.project_id.clone();
let output = state
.index_folder_for_session(
&opened.session_id,
IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: None,
add: Some(true),
},
)
.expect("additive open B");
assert!(
output.contains("added to working set"),
"additive open should report working-set addition: {output}"
);
let sessions = state.sessions.read();
let session = sessions.get(&opened.session_id).expect("session");
assert_eq!(session.active_project_id, active_a, "A still active");
let ws = session.working_set.read();
assert_eq!(ws.len(), 2, "working set has A and B after additive open");
for entry in ws.iter() {
assert_eq!(
entry.overlay.delta_count(),
0,
"no overlay write on additive open (project {})",
entry.project_id
);
}
}
#[test]
fn test_retarget_reseeds_working_set_active_entry() {
let project_a = project_dir("symforge-reseed-a");
let project_b = project_dir("symforge-reseed-b");
std::fs::write(project_b.path().join("src").join("b.rs"), "fn b() {}\n")
.expect("write source b");
let state = DaemonState::new();
let opened = state
.open_project_session(OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "reseed".to_string(),
pid: None,
})
.expect("open A");
let active_a = opened.project_id.clone();
state
.index_folder_for_session(
&opened.session_id,
IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: None,
add: None,
},
)
.expect("retarget to B");
let project_b_id =
project_key(&canonical_project_root(project_b.path()).expect("canonical b"));
let sessions = state.sessions.read();
let session = sessions.get(&opened.session_id).expect("session");
assert_eq!(session.active_project_id, project_b_id, "active is now B");
let ws = session.working_set.read();
assert_eq!(ws.len(), 1, "single re-seeded active entry after retarget");
assert!(
ws.get(&active_a).is_none(),
"stale pre-retarget entry (A) must be dropped"
);
let entry = ws
.get(&project_b_id)
.expect("working set re-seeded with the new active project B");
assert_eq!(
entry.overlay.delta_count(),
0,
"re-seeded overlay must be empty"
);
assert!(
entry.overlay.is_valid_against(&entry.base),
"re-seeded overlay fenced to its base"
);
}
#[test]
fn test_concurrent_session_lifecycle_no_deadlock_or_panic() {
use std::sync::Arc as StdArc;
let shared_roots: Vec<TempDir> = (0..4)
.map(|i| project_dir(&format!("symforge-stress-shared-{i}")))
.collect();
let shared_root_paths: StdArc<Vec<String>> = StdArc::new(
shared_roots
.iter()
.map(|d| d.path().display().to_string())
.collect(),
);
let state = StdArc::new(DaemonState::new());
const THREADS: usize = 8;
const ITERS: usize = 40;
let mut handles = Vec::with_capacity(THREADS);
for t in 0..THREADS {
let state = StdArc::clone(&state);
let shared_root_paths = StdArc::clone(&shared_root_paths);
let private_root = project_dir(&format!("symforge-stress-private-{t}"));
let private_path = private_root.path().display().to_string();
let retarget_root = project_dir(&format!("symforge-stress-retarget-{t}"));
let retarget_path = retarget_root.path().display().to_string();
handles.push(std::thread::spawn(move || {
let _private_root = private_root;
let _retarget_root = retarget_root;
for i in 0..ITERS {
let root = if i % 2 == 0 {
shared_root_paths[(t + i) % shared_root_paths.len()].clone()
} else {
private_path.clone()
};
let opened = state
.open_project_session(OpenProjectRequest {
project_root: root.clone(),
client_name: "stress".to_string(),
pid: Some((t * 1000 + i) as u32),
})
.expect(
"open_project_session must succeed under contention (D17 fail-never)",
);
let _ = state.session_runtime(&opened.session_id);
let _ = state.health();
let _ = state.list_projects();
let _ = state.list_sessions(&opened.project_id);
let _ = state.index_folder_for_session(
&opened.session_id,
IndexFolderInput {
path: retarget_path.clone(),
idempotency_key: None,
add: Some(i % 2 == 1),
},
);
let _ = state.close_session(&opened.session_id);
}
}));
}
for handle in handles {
handle.join().expect("stress worker thread panicked");
}
drop(shared_roots);
assert_eq!(
state.health().session_count,
0,
"all sessions closed after the stress loop"
);
assert!(
state.list_projects().is_empty(),
"all projects removed after their last session closed"
);
}
#[test]
fn test_index_folder_for_session_refuses_sensitive_root() {
let project = project_dir("symforge-daemon-sensitive");
let state = DaemonState::new();
let opened = state
.open_project_session(OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "claude".to_string(),
pid: None,
})
.expect("session");
#[cfg(windows)]
let sensitive = r"C:\Windows";
#[cfg(unix)]
let sensitive = "/etc";
let result = state
.index_folder_for_session(
&opened.session_id,
IndexFolderInput {
path: sensitive.to_string(),
idempotency_key: None,
add: None,
},
)
.expect("refusal must be a clean Ok response, never an Err or panic");
assert!(
result.contains("Refused to index sensitive system path"),
"daemon path must refuse sensitive root `{sensitive}`, got: {result}"
);
let projects = state.list_projects();
assert_eq!(
projects.len(),
1,
"refusal must not create a project for the sensitive root"
);
}
#[test]
fn test_open_project_session_refuses_sensitive_root() {
let state = DaemonState::new();
#[cfg(windows)]
let sensitive = r"C:\Windows";
#[cfg(unix)]
let sensitive = "/etc";
let result = state.open_project_session(OpenProjectRequest {
project_root: sensitive.to_string(),
client_name: "claude".to_string(),
pid: None,
});
let err = result.expect_err("sensitive root must be refused, not opened");
let msg = err.to_string();
assert!(
msg.contains("Refused to open session for sensitive system path"),
"open_project_session must refuse sensitive root `{sensitive}`, got: {msg}"
);
assert!(
state.list_projects().is_empty(),
"refusal must not create a project for the sensitive root"
);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn test_close_session_reaps_all_working_set_projects_and_watchers() {
let project_a = project_dir("symforge-reap-a");
let project_b = project_dir("symforge-reap-b");
std::fs::write(project_b.path().join("src").join("b.rs"), "fn b() {}\n")
.expect("write source b");
let state = DaemonState::new();
let opened = state
.open_project_session(OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "reap".to_string(),
pid: None,
})
.expect("open A");
let active_a = opened.project_id.clone();
state
.index_folder_for_session(
&opened.session_id,
IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: None,
add: Some(true),
},
)
.expect("additive open B");
let project_b_id =
project_key(&canonical_project_root(project_b.path()).expect("canonical b"));
assert_eq!(
state.list_projects().len(),
2,
"A and B both open before close"
);
let (token_a, token_b, watcher_a_live, watcher_b_live) = {
let projects = state.projects.read();
let a = projects.get(&active_a).expect("A loaded");
let b = projects.get(&project_b_id).expect("B loaded");
(
Arc::clone(&a.stop_token),
Arc::clone(&b.stop_token),
a.watcher_task.is_some(),
b.watcher_task.is_some(),
)
};
assert!(
watcher_a_live && watcher_b_live,
"both projects must have a live watcher task before close \
(A: {watcher_a_live}, B: {watcher_b_live})"
);
assert!(
!token_a.load(Ordering::Acquire) && !token_b.load(Ordering::Acquire),
"watcher stop tokens must be unset (false) while the projects are live"
);
let closed = state
.close_session(&opened.session_id)
.expect("close session");
assert_eq!(
closed.project_id, active_a,
"reported pid is the active project A"
);
assert_eq!(closed.remaining_sessions, 0);
assert!(closed.project_removed, "active project A reaped");
assert!(
state.list_projects().is_empty(),
"close_session must reap BOTH A and B, leaving no open project: {:?}",
state.list_projects()
);
assert!(
token_a.load(Ordering::Acquire),
"A's watcher stop_token must be set after close (watcher torn down)"
);
assert!(
token_b.load(Ordering::Acquire),
"B's watcher stop_token must be set after close (additive sibling watcher torn down)"
);
}
#[test]
fn test_close_session_removes_project_when_last_session_leaves() {
let project = project_dir("symforge-daemon-d");
let state = DaemonState::new();
let first = state
.open_project_session(OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "claude".to_string(),
pid: None,
})
.expect("first session");
let second = state
.open_project_session(OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "codex".to_string(),
pid: None,
})
.expect("second session");
let close_first = state
.close_session(&first.session_id)
.expect("close first session");
assert_eq!(close_first.remaining_sessions, 1);
assert!(!close_first.project_removed);
assert_eq!(state.list_projects().len(), 1);
let close_second = state
.close_session(&second.session_id)
.expect("close second session");
assert_eq!(close_second.remaining_sessions, 0);
assert!(close_second.project_removed);
assert!(state.list_projects().is_empty());
}
#[test]
fn test_close_session_handles_orphan_session_record_without_panic() {
let state = DaemonState::new();
let session_id = "stale-session".to_string();
state.sessions.write().insert(
session_id.clone(),
SessionRecord {
session_id: session_id.clone(),
active_project_id: "missing-project".to_string(),
working_set: Arc::new(RwLock::new(WorkingSet::new())),
client_name: "codex".to_string(),
pid: Some(777),
opened_at: SystemTime::now(),
last_seen_at: AtomicU64::new(now_epoch_millis()),
},
);
let closed = state
.close_session(&session_id)
.expect("orphan session should still close");
assert_eq!(closed.session_id, session_id);
assert_eq!(closed.project_id, "orphan");
assert_eq!(closed.remaining_sessions, 0);
assert!(!closed.project_removed);
assert!(state.close_session(&closed.session_id).is_none());
}
#[test]
fn test_heartbeat_updates_known_session() {
let project = project_dir("symforge-daemon-e");
let state = DaemonState::new();
let opened = state
.open_project_session(OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "claude".to_string(),
pid: Some(123),
})
.expect("session");
let known = state.heartbeat(&opened.session_id);
let unknown = state.heartbeat("missing-session");
assert!(known.known_session);
assert!(!unknown.known_session);
}
#[test]
fn test_project_health_and_sessions_expose_instance_metadata() {
let project = project_dir("symforge-daemon-f");
let state = DaemonState::new();
let first = state
.open_project_session(OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "claude".to_string(),
pid: Some(111),
})
.expect("first session");
let second = state
.open_project_session(OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "codex".to_string(),
pid: Some(222),
})
.expect("second session");
let health = state
.project_health(&first.project_id)
.expect("project health should exist");
assert_eq!(health.project_id, first.project_id);
assert_eq!(health.session_count, 2);
assert_eq!(health.index_state, "Ready");
let sessions = state
.list_sessions(&first.project_id)
.expect("session list should exist");
assert_eq!(sessions.len(), 2);
assert_eq!(sessions[0].project_id, first.project_id);
assert!(
sessions
.iter()
.any(|session| session.client_name == "claude")
);
assert!(
sessions
.iter()
.any(|session| session.client_name == "codex")
);
assert!(sessions.iter().any(|session| session.pid == Some(111)));
assert!(sessions.iter().any(|session| session.pid == Some(222)));
assert_ne!(first.session_id, second.session_id);
}
#[tokio::test]
async fn test_spawn_daemon_serves_project_and_session_endpoints() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project = project_dir("symforge-daemon-http");
let handle = spawn_daemon("127.0.0.1").await.expect("spawn daemon");
let client = authed_client(&handle);
let base_url = format!("http://127.0.0.1:{}", handle.port);
let daemon_health = client
.get(format!("{base_url}/health"))
.send()
.await
.expect("health request")
.error_for_status()
.expect("health status")
.json::<DaemonHealth>()
.await
.expect("health body");
assert_eq!(daemon_health.project_count, 0);
assert_eq!(daemon_health.session_count, 0);
assert_eq!(daemon_health.daemon_version, env!("CARGO_PKG_VERSION"));
assert!(daemon_health.auth_required);
assert!(!daemon_health.executable_path.is_empty());
let opened = client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "codex".to_string(),
pid: Some(4242),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let project_health = client
.get(format!(
"{base_url}/v1/projects/{}/health",
opened.project_id
))
.send()
.await
.expect("project health request")
.error_for_status()
.expect("project health status")
.json::<ProjectHealth>()
.await
.expect("project health body");
assert_eq!(project_health.project_id, opened.project_id);
assert_eq!(project_health.session_count, 1);
assert_eq!(project_health.index_state, "Ready");
let sessions = client
.get(format!(
"{base_url}/v1/projects/{}/sessions",
opened.project_id
))
.send()
.await
.expect("sessions request")
.error_for_status()
.expect("sessions status")
.json::<Vec<SessionSummary>>()
.await
.expect("sessions body");
assert_eq!(sessions.len(), 1);
assert_eq!(sessions[0].session_id, opened.session_id);
assert_eq!(sessions[0].client_name, "codex");
assert_eq!(sessions[0].pid, Some(4242));
let heartbeat = client
.post(format!(
"{base_url}/v1/sessions/{}/heartbeat",
opened.session_id
))
.send()
.await
.expect("heartbeat request")
.error_for_status()
.expect("heartbeat status")
.json::<HeartbeatResponse>()
.await
.expect("heartbeat body");
assert!(heartbeat.known_session);
let closed = client
.delete(format!("{base_url}/v1/sessions/{}", opened.session_id))
.send()
.await
.expect("close request")
.error_for_status()
.expect("close status")
.json::<CloseSessionResponse>()
.await
.expect("close body");
assert!(closed.project_removed);
assert_eq!(closed.remaining_sessions, 0);
let final_health = client
.get(format!("{base_url}/health"))
.send()
.await
.expect("final health request")
.error_for_status()
.expect("final health status")
.json::<DaemonHealth>()
.await
.expect("final health body");
assert_eq!(final_health.project_count, 0);
assert_eq!(final_health.session_count, 0);
assert_eq!(final_health.daemon_version, env!("CARGO_PKG_VERSION"));
assert!(!final_health.executable_path.is_empty());
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&daemon_home.path().join(LEGACY_DAEMON_PORT_FILE)).await;
wait_for_path_absent(&daemon_home.path().join(LEGACY_DAEMON_PID_FILE)).await;
assert!(
!daemon_home.path().join(LEGACY_DAEMON_PORT_FILE).exists(),
"daemon port file should be removed on shutdown"
);
assert!(
!daemon_home.path().join(LEGACY_DAEMON_PID_FILE).exists(),
"daemon pid file should be removed on shutdown"
);
}
#[tokio::test]
async fn test_daemon_auth_token_protects_session_tool_and_sidecar_routes() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _home_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let _bind_guard = EnvVarGuard::unset(DAEMON_BIND_ENV);
let _allow_guard = EnvVarGuard::unset(DAEMON_ALLOW_NON_LOOPBACK_ENV);
let token = "sfr03-test-token";
let _auth_guard = EnvVarGuard::set_str(DAEMON_AUTH_TOKEN_ENV, token);
let project = project_dir("symforge-daemon-auth");
let handle = spawn_daemon("127.0.0.1").await.expect("spawn daemon");
let client = reqwest::Client::new();
let base_url = format!("http://127.0.0.1:{}", handle.port);
let health_body = client
.get(format!("{base_url}/health"))
.send()
.await
.expect("health request")
.error_for_status()
.expect("health status")
.text()
.await
.expect("health body");
assert!(
!health_body.contains(token),
"health body must not leak auth token"
);
let daemon_health: DaemonHealth = serde_json::from_str(&health_body).expect("health json");
assert!(daemon_health.auth_required);
let missing_projects = client
.get(format!("{base_url}/v1/projects"))
.send()
.await
.expect("projects request");
assert_eq!(missing_projects.status(), StatusCode::UNAUTHORIZED);
let missing_body = missing_projects.text().await.expect("missing auth body");
assert!(
!missing_body.contains(token),
"401 body must not leak auth token"
);
let wrong_open = client
.post(format!("{base_url}/v1/sessions/open"))
.bearer_auth("wrong-token")
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "codex".to_string(),
pid: Some(5150),
})
.send()
.await
.expect("wrong auth open request");
assert_eq!(wrong_open.status(), StatusCode::UNAUTHORIZED);
let wrong_body = wrong_open.text().await.expect("wrong auth body");
assert!(
!wrong_body.contains(token),
"wrong-token body must not leak auth token"
);
let opened = client
.post(format!("{base_url}/v1/sessions/open"))
.bearer_auth(token)
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "codex".to_string(),
pid: Some(5150),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
client
.get(format!("{base_url}/v1/projects"))
.bearer_auth(token)
.send()
.await
.expect("authorized projects request")
.error_for_status()
.expect("authorized projects status");
let missing_tool = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/health",
opened.session_id
))
.json(&serde_json::json!({}))
.send()
.await
.expect("missing tool auth request");
assert_eq!(missing_tool.status(), StatusCode::UNAUTHORIZED);
let tool_body = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/health",
opened.session_id
))
.bearer_auth(token)
.json(&serde_json::json!({}))
.send()
.await
.expect("authorized tool request")
.error_for_status()
.expect("authorized tool status")
.text()
.await
.expect("authorized tool body");
assert!(
tool_body.contains("Status:"),
"health tool response should succeed: {tool_body}"
);
assert!(
!tool_body.contains(token),
"tool response must not leak auth token"
);
let missing_sidecar = client
.get(format!(
"{base_url}/v1/sessions/{}/sidecar/health",
opened.session_id
))
.send()
.await
.expect("missing sidecar auth request");
assert_eq!(missing_sidecar.status(), StatusCode::UNAUTHORIZED);
client
.get(format!(
"{base_url}/v1/sessions/{}/sidecar/health",
opened.session_id
))
.bearer_auth(token)
.send()
.await
.expect("authorized sidecar request")
.error_for_status()
.expect("authorized sidecar status");
client
.post(format!(
"{base_url}/v1/sessions/{}/heartbeat",
opened.session_id
))
.bearer_auth(token)
.send()
.await
.expect("authorized heartbeat request")
.error_for_status()
.expect("authorized heartbeat status");
client
.delete(format!("{base_url}/v1/sessions/{}", opened.session_id))
.bearer_auth(token)
.send()
.await
.expect("authorized close request")
.error_for_status()
.expect("authorized close status");
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&daemon_home.path().join(LEGACY_DAEMON_PORT_FILE)).await;
}
#[tokio::test]
async fn test_cross_project_query_returns_attributed_hits_from_both_projects() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project_a = project_dir("symforge-xproj-a");
let project_b = project_dir("symforge-xproj-b");
std::fs::write(
project_a.path().join("src").join("a.rs"),
"pub fn xproj_marker_alpha() -> u32 { 1 }\n",
)
.expect("write source a");
std::fs::write(
project_b.path().join("src").join("b.rs"),
"pub fn xproj_marker_beta() -> u32 { 2 }\n",
)
.expect("write source b");
let handle = spawn_daemon("127.0.0.1").await.expect("spawn daemon");
let base_url = format!("http://127.0.0.1:{}", handle.port);
let http = authed_client(&handle);
let opened = http
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "xproj".to_string(),
pid: Some(std::process::id()),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let project_a_id = opened.project_id.clone();
let project_b_id =
project_key(&canonical_project_root(project_b.path()).expect("canonical b"));
let index_a = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/index_folder",
opened.session_id
))
.json(&IndexFolderInput {
path: project_a.path().display().to_string(),
idempotency_key: None,
add: None,
})
.send()
.await
.expect("index A request")
.error_for_status()
.expect("index A status")
.text()
.await
.expect("index A body");
assert!(index_a.contains("Indexed"), "index A: {index_a}");
let index_b = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/index_folder",
opened.session_id
))
.json(&IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: None,
add: Some(true),
})
.send()
.await
.expect("index B request")
.error_for_status()
.expect("index B status")
.text()
.await
.expect("index B body");
assert!(
index_b.contains("added to working set"),
"additive index B: {index_b}"
);
let cross = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/search_symbols",
opened.session_id
))
.json(&serde_json::json!({
"query": "xproj_marker",
"projects": ["*"]
}))
.send()
.await
.expect("cross query request")
.error_for_status()
.expect("cross query status")
.text()
.await
.expect("cross query body");
assert!(
cross.contains("xproj_marker_alpha"),
"cross-project query must surface A's symbol: {cross}"
);
assert!(
cross.contains("xproj_marker_beta"),
"cross-project query must surface B's symbol: {cross}"
);
assert!(
cross.contains(&format!("project: {project_a_id}")),
"A must be attributed by project id: {cross}"
);
assert!(
cross.contains(&format!("project: {project_b_id}")),
"B must be attributed by project id: {cross}"
);
let active_only = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/search_symbols",
opened.session_id
))
.json(&serde_json::json!({
"query": "xproj_marker"
}))
.send()
.await
.expect("active query request")
.error_for_status()
.expect("active query status")
.text()
.await
.expect("active query body");
assert!(
active_only.contains("xproj_marker_alpha"),
"active-only query must surface A's symbol: {active_only}"
);
assert!(
!active_only.contains("xproj_marker_beta"),
"active-only query must NOT surface B's symbol (single active project): {active_only}"
);
assert!(
!active_only.contains("project: "),
"single-active query must render flat (no project header): {active_only}"
);
let explicit_active = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/search_symbols",
opened.session_id
))
.json(&serde_json::json!({
"query": "xproj_marker",
"project": project_a_id
}))
.send()
.await
.expect("explicit active query request")
.error_for_status()
.expect("explicit active query status")
.text()
.await
.expect("explicit active query body");
assert!(
explicit_active.contains("xproj_marker_alpha"),
"explicit active project query must surface A's symbol: {explicit_active}"
);
assert!(
!explicit_active.contains("xproj_marker_beta"),
"explicit active project query must NOT surface B's symbol: {explicit_active}"
);
assert!(
!explicit_active.contains("Cross-project queries"),
"explicit active project must not hit the local cross-project refusal: {explicit_active}"
);
assert!(
!explicit_active.contains("project: "),
"explicit active project must render as the flat single-project route: {explicit_active}"
);
let scoped_out = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/search_symbols",
opened.session_id
))
.json(&serde_json::json!({
"query": "xproj_marker",
"projects": ["*"],
"path_prefix": "no_such_dir"
}))
.send()
.await
.expect("scoped query request")
.error_for_status()
.expect("B1: path_prefix must NOT be refused (HTTP 200, not 400)")
.text()
.await
.expect("scoped query body");
assert!(
!scoped_out.contains("xproj_marker_alpha") && !scoped_out.contains("xproj_marker_beta"),
"B1: a non-matching path_prefix must scope BOTH projects out \
(honored, not ignored): {scoped_out}"
);
let lang_python = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/search_symbols",
opened.session_id
))
.json(&serde_json::json!({
"query": "xproj_marker",
"projects": ["*"],
"language": "Python"
}))
.send()
.await
.expect("python query request")
.error_for_status()
.expect("B1: language must NOT be refused (HTTP 200, not 400)")
.text()
.await
.expect("python query body");
assert!(
!lang_python.contains("xproj_marker_alpha")
&& !lang_python.contains("xproj_marker_beta"),
"B1: language=Python must scope out the Rust symbols cross-project: {lang_python}"
);
let lang_rust = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/search_symbols",
opened.session_id
))
.json(&serde_json::json!({
"query": "xproj_marker",
"projects": ["*"],
"language": "Rust"
}))
.send()
.await
.expect("rust query request")
.error_for_status()
.expect("rust query status")
.text()
.await
.expect("rust query body");
assert!(
lang_rust.contains("xproj_marker_alpha") && lang_rust.contains("xproj_marker_beta"),
"B1: language=Rust keeps both Rust symbols cross-project: {lang_rust}"
);
let text_all = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/search_text",
opened.session_id
))
.json(&serde_json::json!({ "query": "xproj_marker", "projects": ["*"] }))
.send()
.await
.expect("text all request")
.error_for_status()
.expect("text all status")
.text()
.await
.expect("text all body");
assert!(
text_all.contains("xproj_marker_alpha") && text_all.contains("xproj_marker_beta"),
"B1 control: unscoped cross-project text search finds both projects: {text_all}"
);
let text_scoped = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/search_text",
opened.session_id
))
.json(&serde_json::json!({
"query": "xproj_marker",
"projects": ["*"],
"path_prefix": "no_such_dir"
}))
.send()
.await
.expect("text scoped request")
.error_for_status()
.expect("B1: search_text path_prefix must NOT be refused (200, not 400)")
.text()
.await
.expect("text scoped body");
assert!(
!text_scoped.contains("xproj_marker_alpha")
&& !text_scoped.contains("xproj_marker_beta"),
"B1: non-matching path_prefix must scope BOTH projects' text out (honored): {text_scoped}"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&daemon_home.path().join(LEGACY_DAEMON_PORT_FILE)).await;
}
#[tokio::test]
async fn test_cross_project_read_is_fresh_after_watcher_reindex() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project_a = project_dir("symforge-fresh-a");
let project_b = project_dir("symforge-fresh-b");
let b_source = project_b.path().join("src").join("b.rs");
std::fs::write(
project_a.path().join("src").join("a.rs"),
"pub fn xproj_marker_alpha() -> u32 { 1 }\n",
)
.expect("write source a");
std::fs::write(&b_source, "pub fn xproj_marker_beta() -> u32 { 2 }\n")
.expect("write source b");
let handle = spawn_daemon("127.0.0.1").await.expect("spawn daemon");
let base_url = format!("http://127.0.0.1:{}", handle.port);
let http = authed_client(&handle);
let opened = http
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "fresh".to_string(),
pid: Some(std::process::id()),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let session_id = opened.session_id.clone();
let canonical_b = canonical_project_root(project_b.path()).expect("canonical b");
let project_b_id = project_key(&canonical_b);
http.post(format!(
"{base_url}/v1/sessions/{session_id}/tools/index_folder"
))
.json(&IndexFolderInput {
path: project_a.path().display().to_string(),
idempotency_key: None,
add: None,
})
.send()
.await
.expect("index A request")
.error_for_status()
.expect("index A status");
http.post(format!(
"{base_url}/v1/sessions/{session_id}/tools/index_folder"
))
.json(&IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: None,
add: Some(true),
})
.send()
.await
.expect("index B request")
.error_for_status()
.expect("index B status");
let baseline = http
.post(format!(
"{base_url}/v1/sessions/{session_id}/tools/search_symbols"
))
.json(&serde_json::json!({ "query": "xproj_marker", "projects": ["*"] }))
.send()
.await
.expect("baseline request")
.error_for_status()
.expect("baseline status")
.text()
.await
.expect("baseline body");
assert!(
baseline.contains("xproj_marker_beta"),
"baseline cross-read must surface B's original symbol: {baseline}"
);
assert!(
!baseline.contains("xproj_marker_gamma"),
"baseline must NOT yet contain the not-written symbol: {baseline}"
);
let b_key = BaseKey::new(canonical_b.clone(), CommitId::Dirtyless);
let gen_before =
state_base_generation(&handle.state, &b_key).expect("B base interned at open");
let key_count_before = handle.state.bases.read().len();
let canonical_a = canonical_project_root(project_a.path()).expect("canonical a");
let a_key = BaseKey::new(canonical_a, CommitId::Dirtyless);
let a_gen_before =
state_base_generation(&handle.state, &a_key).expect("A base interned at open");
std::fs::write(&b_source, "pub fn xproj_marker_gamma() -> u32 { 3 }\n")
.expect("rewrite source b");
{
let projects = handle.state.projects.read();
let project_b_inst = projects
.get(&project_b_id)
.expect("project B loaded in daemon");
project_b_inst
.index
.reload(&canonical_b)
.expect("deterministic B reload (watcher-equivalent publish)");
}
let fresh = http
.post(format!(
"{base_url}/v1/sessions/{session_id}/tools/search_symbols"
))
.json(&serde_json::json!({ "query": "xproj_marker", "projects": ["*"] }))
.send()
.await
.expect("fresh request")
.error_for_status()
.expect("fresh status")
.text()
.await
.expect("fresh body");
assert!(
fresh.contains("xproj_marker_gamma"),
"SC-1: cross-read after watcher reindex must surface B's NEW symbol: {fresh}"
);
assert!(
!fresh.contains("xproj_marker_beta"),
"SC-2: cross-read must NOT surface B's DELETED symbol (stale ghost): {fresh}"
);
assert!(
fresh.contains("xproj_marker_alpha"),
"A must remain present after B's refresh: {fresh}"
);
let gen_after = state_base_generation(&handle.state, &b_key)
.expect("B base still interned after refresh");
assert!(
gen_after > gen_before,
"control: force-replace must advance B's base_generation \
(before={gen_before}, after={gen_after}); a frozen base would not"
);
let a_gen_after = state_base_generation(&handle.state, &a_key)
.expect("A base still interned after refresh");
assert_eq!(
a_gen_after, a_gen_before,
"mismatch-gate: untouched project A must NOT be re-interned \
(before={a_gen_before}, after={a_gen_after})"
);
{
let bases = handle.state.bases.read();
let table_base = bases.get(&b_key).expect("B base in table after refresh");
let sessions = handle.state.sessions.read();
let session = sessions.get(&session_id).expect("session present");
let ws = session.working_set.read();
let entry = ws.get(&project_b_id).expect("B entry in working set");
assert!(
Arc::ptr_eq(table_base, &entry.base),
"SC-002: the working-set entry must share the SAME interned base Arc"
);
assert_eq!(
bases.len(),
key_count_before,
"SC-002: force-replace must REPLACE the value, not add a duplicate key"
);
}
std::fs::write(&b_source, "pub fn xproj_marker_delta() -> u32 { 4 }\n")
.expect("rewrite source b (delta)");
{
let projects = handle.state.projects.read();
projects
.get(&project_b_id)
.expect("project B loaded in daemon")
.index
.reload(&canonical_b)
.expect("deterministic B reload (delta)");
}
let lone_b = http
.post(format!(
"{base_url}/v1/sessions/{session_id}/tools/search_symbols"
))
.json(&serde_json::json!({ "query": "xproj_marker", "projects": [project_b_id] }))
.send()
.await
.expect("lone-B request")
.error_for_status()
.expect("lone-B status")
.text()
.await
.expect("lone-B body");
assert!(
lone_b.contains("xproj_marker_delta"),
"lone non-active target: refresh must fire for Targets::One(B) too: {lone_b}"
);
assert!(
!lone_b.contains("xproj_marker_gamma"),
"lone non-active target: B's superseded symbol must be gone: {lone_b}"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&daemon_home.path().join(LEGACY_DAEMON_PORT_FILE)).await;
}
fn state_base_generation(state: &SharedDaemonState, key: &BaseKey) -> Option<u64> {
state.bases.read().get(key).map(|b| b.base_generation)
}
#[test]
fn test_cross_project_symbols_output_is_capped_and_discloses_truncation() {
use crate::live_index::search::SymbolMatchTier;
use crate::live_index::view::{ProjectHit, ViewSymbolHit};
let hits: Vec<ProjectHit<ViewSymbolHit>> = (0..5)
.map(|i| ProjectHit {
project_id: if i < 3 { "proj-a" } else { "proj-b" }.to_string(),
hit: ViewSymbolHit {
name: format!("sym_{i}"),
path: format!("src/f{i}.rs"),
kind: "fn".to_string(),
line: i + 1,
tier: SymbolMatchTier::Exact,
},
})
.collect();
let capped = format_cross_project_symbols(&hits, "sym", true, 2);
assert!(
capped.starts_with("2 of 5 matches across projects (truncated;"),
"header must disclose shown-of-total truncation: {capped}"
);
assert!(
capped.contains("query a single project for the full set"),
"truncation must carry the corrective hint: {capped}"
);
assert!(capped.contains("sym_0") && capped.contains("sym_1"));
assert!(
!capped.contains("sym_2") && !capped.contains("sym_4"),
"hits beyond the cap must NOT be rendered: {capped}"
);
let full = format_cross_project_symbols(&hits, "sym", true, 100);
assert!(
full.starts_with("5 matches across projects\n"),
"uncapped header must not claim truncation: {full}"
);
assert!(
full.contains("sym_4"),
"all hits rendered when under cap: {full}"
);
assert!(
!full.contains("truncated"),
"no truncation notice when under cap: {full}"
);
}
#[test]
fn test_cross_project_result_cap_clamps_limit() {
assert_eq!(
cross_project_result_cap(None),
CROSS_PROJECT_DEFAULT_RESULT_CAP,
"no limit -> default cap"
);
assert_eq!(
cross_project_result_cap(Some(10)),
10,
"small limit honored"
);
assert_eq!(
cross_project_result_cap(Some(0)),
1,
"zero clamps up to 1 (cap never disabled)"
);
assert_eq!(
cross_project_result_cap(Some(u32::MAX)),
CROSS_PROJECT_MAX_RESULT_CAP,
"absurd limit clamps to the hard ceiling"
);
}
#[test]
fn test_cross_project_token_budget_truncates_and_discloses() {
let body = (0..50)
.map(|i| format!("line {i} with some content\n"))
.collect::<String>();
let out = apply_cross_project_token_budget(body.clone(), Some(10));
assert!(out.len() < body.len(), "budget must shrink the body");
assert!(
out.contains("truncated to fit max_tokens=10"),
"truncation must be disclosed: {out}"
);
assert!(
out.ends_with('\n'),
"truncated body ends on a line boundary"
);
assert_eq!(apply_cross_project_token_budget(body.clone(), None), body);
assert_eq!(
apply_cross_project_token_budget(body.clone(), Some(0)),
body
);
}
#[test]
fn test_reject_unsupported_cross_project_scoping_per_tool() {
use serde_json::json;
assert!(
reject_unsupported_cross_project_scoping(
"search_symbols",
&json!({ "query": "x", "path_prefix": "src/" }),
)
.is_ok(),
"path_prefix is now honored cross-project and must NOT be refused"
);
assert!(
reject_unsupported_cross_project_scoping(
"search_symbols",
&json!({ "query": "x", "language": "Rust" }),
)
.is_ok(),
"language is now honored cross-project and must NOT be refused"
);
assert!(
reject_unsupported_cross_project_scoping(
"search_symbols",
&json!({ "query": "x", "kind": "fn" }),
)
.is_ok(),
"kind IS honored cross-project and must NOT be refused"
);
assert!(
reject_unsupported_cross_project_scoping(
"search_text",
&json!({ "query": "x", "path_prefix": "src/", "language": "Rust" }),
)
.is_ok(),
"search_text path_prefix/language are now honored cross-project"
);
let structural_err = reject_unsupported_cross_project_scoping(
"search_text",
&json!({ "query": "x", "structural": true }),
)
.expect_err("structural must be refused");
assert!(
structural_err
.to_string()
.contains("structural scoping is not supported")
&& structural_err
.to_string()
.contains("query a single project for scoped results"),
"structural refusal must name the param + corrective hint: {structural_err}"
);
for (field, value) in [
("path", json!("src/db.rs")),
("symbol_kind", json!("fn")),
("direction", json!("trait")),
] {
let err = reject_unsupported_cross_project_scoping(
"find_references",
&json!({ "name": "x", field: value }),
)
.unwrap_err()
.to_string();
assert!(
err.contains(&format!("{field} scoping is not supported")),
"{field} must be refused on find_references: {err}"
);
}
assert!(
reject_unsupported_cross_project_scoping(
"find_references",
&json!({ "name": "x", "path": " " }),
)
.is_ok(),
"blank path value must not trip the refusal"
);
}
#[test]
fn test_execute_cross_project_read_rejects_scoping_before_query() {
use crate::live_index::store::LiveIndex;
use crate::live_index::view::{BaseKey, CommitId, IndexBase, WorkingSet};
use serde_json::json;
let base = Arc::new(IndexBase::new(
BaseKey::new("/synthetic/root", CommitId::Dirtyless),
Arc::new(LiveIndex::empty_live_index()),
1,
));
let mut ws = WorkingSet::new();
ws.add("proj-x", base);
let err = execute_cross_project_read(
"find_references",
json!({ "name": "anything", "direction": "trait" }),
Targets::Subset(vec!["proj-x".to_string()]),
&ws,
)
.expect_err("scoping param must be refused");
assert!(
err.to_string()
.contains("direction scoping is not supported with cross-project targeting"),
"cross-project read must refuse the unsupported scoping param: {err}"
);
}
#[tokio::test]
async fn test_daemon_is_fail_closed_without_env_token() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _home_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let _bind_guard = EnvVarGuard::unset(DAEMON_BIND_ENV);
let _allow_guard = EnvVarGuard::unset(DAEMON_ALLOW_NON_LOOPBACK_ENV);
let _auth_guard = EnvVarGuard::unset(DAEMON_AUTH_TOKEN_ENV);
let project = project_dir("symforge-daemon-failclosed");
let handle = spawn_daemon("127.0.0.1").await.expect("spawn daemon");
let base_url = format!("http://127.0.0.1:{}", handle.port);
let token_path = daemon_home.path().join(daemon_token_file_name());
assert!(
token_path.exists(),
"daemon must persist an auth token file even without an env pin"
);
let file_token = std::fs::read_to_string(&token_path)
.expect("read token file")
.trim()
.to_string();
assert!(!file_token.is_empty(), "persisted token must be non-empty");
assert_eq!(
file_token, handle.state.auth_token,
"the persisted token must match the token the daemon enforces"
);
let bare = reqwest::Client::new();
let health_body = bare
.get(format!("{base_url}/health"))
.send()
.await
.expect("health request")
.error_for_status()
.expect("health status")
.text()
.await
.expect("health body");
assert!(
!health_body.contains(&file_token),
"health body must not leak the auth token"
);
let health: DaemonHealth = serde_json::from_str(&health_body).expect("health json");
assert!(health.auth_required, "auth must always be required");
let unauth = bare
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "codex".to_string(),
pid: Some(7000),
})
.send()
.await
.expect("unauth open request");
assert_eq!(
unauth.status(),
StatusCode::UNAUTHORIZED,
"a request without the token must be rejected"
);
let opened = bare
.post(format!("{base_url}/v1/sessions/open"))
.bearer_auth(&file_token)
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "codex".to_string(),
pid: Some(7000),
})
.send()
.await
.expect("authed open request")
.error_for_status()
.expect("authed open status")
.json::<OpenProjectResponse>()
.await
.expect("authed open body");
assert!(!opened.session_id.is_empty());
assert_eq!(
resolve_daemon_auth_token().as_deref(),
Some(file_token.as_str()),
"client token resolution must read the persisted token file"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&daemon_home.path().join(LEGACY_DAEMON_PORT_FILE)).await;
}
#[tokio::test]
async fn test_daemon_executes_session_scoped_tool_calls() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project = project_dir("symforge-daemon-tool");
std::fs::write(project.path().join("src").join("main.rs"), "fn main() {}\n")
.expect("write source");
let handle = spawn_daemon("127.0.0.1").await.expect("spawn daemon");
let client = authed_client(&handle);
let base_url = format!("http://127.0.0.1:{}", handle.port);
let opened = client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "codex".to_string(),
pid: Some(9001),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let response = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/get_repo_map",
opened.session_id
))
.json(&serde_json::json!({
"detail": "full"
}))
.send()
.await
.expect("tool request");
assert!(
response.status().is_success(),
"tool endpoint should succeed, got {}",
response.status()
);
let body = response.text().await.expect("tool body");
assert!(
body.contains("main.rs"),
"repo outline should include the indexed file, got: {body}"
);
let search_files = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/search_files",
opened.session_id
))
.json(&serde_json::json!({
"query": "main.rs",
"limit": 5
}))
.send()
.await
.expect("search_files request");
assert!(
search_files.status().is_success(),
"search_files endpoint should succeed, got {}",
search_files.status()
);
let search_files_body = search_files.text().await.expect("search_files body");
assert!(
search_files_body.contains("src/main.rs"),
"search_files should return the indexed file, got: {search_files_body}"
);
let resolved_path = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/search_files",
opened.session_id
))
.json(&serde_json::json!({
"query": "main.rs",
"resolve": true
}))
.send()
.await
.expect("search_files resolve request");
assert!(
resolved_path.status().is_success(),
"search_files resolve mode should succeed, got {}",
resolved_path.status()
);
let resolved_path_body = resolved_path
.text()
.await
.expect("search_files resolve body");
assert!(
resolved_path_body.contains("src/main.rs"),
"search_files resolve mode should return the indexed file, got: {resolved_path_body}"
);
let reused = client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "codex-reused".to_string(),
pid: Some(9002),
})
.send()
.await
.expect("reused open request")
.error_for_status()
.expect("reused open status")
.json::<OpenProjectResponse>()
.await
.expect("reused open body");
assert_eq!(reused.project_id, opened.project_id);
assert_ne!(reused.session_id, opened.session_id);
let health = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/health_compact",
reused.session_id
))
.json(&serde_json::json!({}))
.send()
.await
.expect("health request")
.error_for_status()
.expect("health status")
.text()
.await
.expect("health body");
assert!(
health.contains("Runtime: mode=daemon_reused_session"),
"daemon health should distinguish reused daemon sessions, got: {health}"
);
assert!(
health.contains(&format!("project_root={}", reused.canonical_root)),
"daemon health should surface canonical project root, got: {health}"
);
assert!(
health.contains(&format!("project_id={}", reused.project_id)),
"daemon health should surface daemon project id, got: {health}"
);
assert!(
health.contains(&format!("session_id={}", reused.session_id)),
"daemon health should surface daemon session id, got: {health}"
);
assert!(
health.contains("index_id=index-"),
"daemon health should surface index identity, got: {health}"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&daemon_home.path().join(LEGACY_DAEMON_PORT_FILE)).await;
}
#[tokio::test]
async fn test_daemon_executes_checkpoint_now_tool_call() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project = project_dir("symforge-daemon-checkpoint");
std::fs::write(project.path().join("src").join("main.rs"), "fn main() {}\n")
.expect("write source");
let handle = spawn_daemon("127.0.0.1").await.expect("spawn daemon");
let client = authed_client(&handle);
let base_url = format!("http://127.0.0.1:{}", handle.port);
let opened = client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "codex".to_string(),
pid: Some(9101),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let response = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/checkpoint_now",
opened.session_id
))
.json(&serde_json::json!({
"verify_after_write": true
}))
.send()
.await
.expect("checkpoint_now request");
assert!(
response.status().is_success(),
"checkpoint_now endpoint should succeed, got {}",
response.status()
);
let body = response.text().await.expect("checkpoint_now body");
assert!(
body.contains("Checkpoint complete"),
"checkpoint_now should report completion, got: {body}"
);
assert!(
!body.contains("unavailable in daemon-proxy mode"),
"checkpoint_now must not hard-fail in daemon-proxy mode, got: {body}"
);
assert!(
!body.contains("unknown tool"),
"daemon must dispatch checkpoint_now, got: {body}"
);
let canonical_root = PathBuf::from(&opened.canonical_root);
assert!(
crate::live_index::persist::load_snapshot(&canonical_root).is_some(),
"checkpoint should write a loadable snapshot under {}/.symforge/index.bin",
canonical_root.display()
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&daemon_home.path().join(LEGACY_DAEMON_PORT_FILE)).await;
}
#[tokio::test]
async fn test_daemon_port_if_compatible_accepts_matching_identity() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let health = DaemonState::new().health();
let (port, shutdown_tx) = spawn_fake_health_server(health).await;
std::fs::write(
daemon_home.path().join(LEGACY_DAEMON_PORT_FILE),
port.to_string(),
)
.expect("write daemon port");
let identity = current_daemon_identity();
let selected = daemon_port_if_compatible(&identity)
.await
.expect("compatible health lookup");
assert_eq!(selected, Some(port));
let _ = shutdown_tx.send(());
}
#[tokio::test]
async fn test_daemon_port_if_compatible_rejects_version_mismatch() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let health = DaemonHealth {
project_count: 0,
session_count: 0,
daemon_version: "0.0.0".to_string(),
executable_path: current_daemon_identity().executable_path,
auth_required: false,
pid: None,
};
let (port, shutdown_tx) = spawn_fake_health_server(health).await;
std::fs::write(
daemon_home.path().join(LEGACY_DAEMON_PORT_FILE),
port.to_string(),
)
.expect("write daemon port");
let identity = current_daemon_identity();
let selected = daemon_port_if_compatible(&identity)
.await
.expect("mismatch health lookup");
assert_eq!(selected, None);
let _ = shutdown_tx.send(());
}
#[test]
fn test_daemon_health_matches_recorded_pid_requires_exact_pid() {
let mut health = DaemonHealth {
project_count: 0,
session_count: 0,
daemon_version: current_daemon_identity().version,
executable_path: current_daemon_identity().executable_path,
auth_required: false,
pid: Some(42),
};
assert!(daemon_health_matches_recorded_pid(&health, 42));
assert!(!daemon_health_matches_recorded_pid(&health, 43));
health.pid = None;
assert!(!daemon_health_matches_recorded_pid(&health, 42));
}
#[tokio::test]
async fn test_stop_incompatible_recorded_daemon_does_not_kill_unrelated_pid() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
#[cfg(windows)]
let mut child = std::process::Command::new("powershell")
.args(["-NoProfile", "-Command", "Start-Sleep -Seconds 30"])
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null())
.spawn()
.expect("spawn long-running child");
#[cfg(not(windows))]
let mut child = std::process::Command::new("sleep")
.arg("30")
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null())
.spawn()
.expect("spawn long-running child");
let child_pid = child.id();
let health = DaemonHealth {
project_count: 0,
session_count: 0,
daemon_version: current_daemon_identity().version,
executable_path: "C:/unrelated/not-symforge-daemon.exe".to_string(),
auth_required: false,
pid: Some(child_pid),
};
let (port, shutdown_tx) = spawn_fake_health_server(health).await;
std::fs::write(
daemon_home.path().join(LEGACY_DAEMON_PORT_FILE),
port.to_string(),
)
.expect("write daemon port");
std::fs::write(
daemon_home.path().join(LEGACY_DAEMON_PID_FILE),
child_pid.to_string(),
)
.expect("write daemon pid");
stop_incompatible_recorded_daemon(¤t_daemon_identity())
.await
.expect("stop incompatible daemon");
assert!(
child.try_wait().expect("poll child").is_none(),
"daemon pid safety checks must not terminate unrelated processes"
);
let _ = child.kill();
let _ = child.wait();
let _ = shutdown_tx.send(());
}
#[tokio::test]
async fn test_stop_incompatible_recorded_daemon_cleans_port_file_without_pid() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let health = DaemonHealth {
project_count: 0,
session_count: 0,
daemon_version: "0.0.0".to_string(),
executable_path: current_daemon_identity().executable_path,
auth_required: false,
pid: None,
};
let (port, shutdown_tx) = spawn_fake_health_server(health).await;
std::fs::write(
daemon_home.path().join(LEGACY_DAEMON_PORT_FILE),
port.to_string(),
)
.expect("write daemon port");
stop_incompatible_recorded_daemon(¤t_daemon_identity())
.await
.expect("stop incompatible daemon");
assert!(
!daemon_home.path().join(LEGACY_DAEMON_PORT_FILE).exists(),
"incompatible daemon port file should be cleared"
);
let _ = shutdown_tx.send(());
}
#[tokio::test]
async fn test_daemon_serves_session_scoped_repo_map_hook_endpoint() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project = project_dir("symforge-daemon-hook");
std::fs::write(project.path().join("src").join("main.rs"), "fn main() {}\n")
.expect("write source");
let handle = spawn_daemon("127.0.0.1").await.expect("spawn daemon");
let client = authed_client(&handle);
let base_url = format!("http://127.0.0.1:{}", handle.port);
let opened = client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "claude".to_string(),
pid: Some(77),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let response = client
.get(format!(
"{base_url}/v1/sessions/{}/sidecar/repo-map",
opened.session_id
))
.send()
.await
.expect("hook request");
assert!(
response.status().is_success(),
"repo-map hook endpoint should succeed, got {}",
response.status()
);
let body = response.text().await.expect("hook body");
assert!(
body.contains("Index: 1 files, 1 symbols"),
"repo-map hook output should come from daemon project instance, got: {body}"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&daemon_home.path().join(LEGACY_DAEMON_PORT_FILE)).await;
}
#[tokio::test]
async fn test_daemon_workflow_repo_start_endpoint_matches_repo_map_route() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project = project_dir("symforge-daemon-workflow-repo-start");
std::fs::write(project.path().join("src").join("main.rs"), "fn main() {}\n")
.expect("write source");
let handle = spawn_daemon("127.0.0.1").await.expect("spawn daemon");
let client = authed_client(&handle);
let base_url = format!("http://127.0.0.1:{}", handle.port);
let opened = client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "claude".to_string(),
pid: Some(78),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let canonical = client
.get(format!(
"{base_url}/v1/sessions/{}/sidecar/repo-map",
opened.session_id
))
.send()
.await
.expect("canonical request")
.error_for_status()
.expect("canonical status")
.text()
.await
.expect("canonical body");
let workflow = client
.get(format!(
"{base_url}/v1/sessions/{}/sidecar/workflows/repo-start",
opened.session_id
))
.send()
.await
.expect("workflow request")
.error_for_status()
.expect("workflow status")
.text()
.await
.expect("workflow body");
assert_eq!(
workflow, canonical,
"workflow repo-start route should stay identical to the canonical repo-map route"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&daemon_home.path().join(LEGACY_DAEMON_PORT_FILE)).await;
}
#[tokio::test]
async fn test_daemon_serves_session_scoped_prompt_context_hook_endpoint() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project = project_dir("symforge-daemon-prompt-hook");
std::fs::write(project.path().join("src").join("main.rs"), "fn main() {}\n")
.expect("write source");
let handle = spawn_daemon("127.0.0.1").await.expect("spawn daemon");
let client = authed_client(&handle);
let base_url = format!("http://127.0.0.1:{}", handle.port);
let opened = client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "claude".to_string(),
pid: Some(88),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let response = client
.get(format!(
"{base_url}/v1/sessions/{}/sidecar/prompt-context",
opened.session_id
))
.query(&[("text", "please inspect src/main.rs")])
.send()
.await
.expect("hook request");
assert!(
response.status().is_success(),
"prompt-context hook endpoint should succeed, got {}",
response.status()
);
let body = response.text().await.expect("hook body");
assert!(
body.contains("src/main.rs") && body.contains("main"),
"prompt-context hook output should come from daemon project instance, got: {body}"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&daemon_home.path().join(LEGACY_DAEMON_PORT_FILE)).await;
}
#[tokio::test]
async fn test_daemon_workflow_prompt_context_endpoint_matches_canonical_route() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project = project_dir("symforge-daemon-workflow-prompt-context");
std::fs::write(project.path().join("src").join("main.rs"), "fn main() {}\n")
.expect("write source");
let handle = spawn_daemon("127.0.0.1").await.expect("spawn daemon");
let client = authed_client(&handle);
let base_url = format!("http://127.0.0.1:{}", handle.port);
let opened = client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "claude".to_string(),
pid: Some(89),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let canonical = client
.get(format!(
"{base_url}/v1/sessions/{}/sidecar/prompt-context",
opened.session_id
))
.query(&[("text", "please inspect src/main.rs")])
.send()
.await
.expect("canonical request")
.error_for_status()
.expect("canonical status")
.text()
.await
.expect("canonical body");
let workflow = client
.get(format!(
"{base_url}/v1/sessions/{}/sidecar/workflows/prompt-context",
opened.session_id
))
.query(&[("text", "please inspect src/main.rs")])
.send()
.await
.expect("workflow request")
.error_for_status()
.expect("workflow status")
.text()
.await
.expect("workflow body");
assert_eq!(
workflow, canonical,
"workflow prompt-context route should stay identical to the canonical prompt-context route"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&daemon_home.path().join(LEGACY_DAEMON_PORT_FILE)).await;
}
#[tokio::test]
async fn test_index_folder_rebinds_session_to_new_project_root() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project_a = project_dir("symforge-daemon-a");
let project_b = project_dir("symforge-daemon-b");
std::fs::write(
project_a.path().join("src").join("old.rs"),
"fn old_fn() {}\n",
)
.expect("write source a");
std::fs::write(
project_b.path().join("src").join("new.rs"),
"fn new_fn() {}\n",
)
.expect("write source b");
let handle = spawn_daemon("127.0.0.1").await.expect("spawn daemon");
let client = authed_client(&handle);
let base_url = format!("http://127.0.0.1:{}", handle.port);
let opened = client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "codex".to_string(),
pid: Some(55),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let reload = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/index_folder",
opened.session_id
))
.json(&IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: None,
add: None,
})
.send()
.await
.expect("index request")
.error_for_status()
.expect("index status")
.text()
.await
.expect("index body");
assert!(
reload.contains("Indexed"),
"index_folder should report success, got: {reload}"
);
let sessions = client
.get(format!(
"{base_url}/v1/projects/{}/sessions",
project_key(&canonical_project_root(project_b.path()).expect("canonical root"))
))
.send()
.await
.expect("session list request")
.error_for_status()
.expect("session list status")
.json::<Vec<SessionSummary>>()
.await
.expect("session list body");
assert_eq!(sessions.len(), 1);
assert_eq!(sessions[0].session_id, opened.session_id);
let outline = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/get_repo_map",
opened.session_id
))
.json(&serde_json::json!({
"detail": "full"
}))
.send()
.await
.expect("outline request")
.error_for_status()
.expect("outline status")
.text()
.await
.expect("outline body");
assert!(
outline.contains("new.rs"),
"rebound session should see new root: {outline}"
);
assert!(
!outline.contains("old.rs"),
"rebound session should no longer point at old root: {outline}"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&daemon_home.path().join(LEGACY_DAEMON_PORT_FILE)).await;
}
#[tokio::test]
async fn test_status_index_matches_daemon_proxy_after_symforge_serve() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _home_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let _surface_guard = EnvVarGuard::set_str("SYMFORGE_SURFACE", "compact");
let project = project_dir("symforge-status-proxy");
std::fs::write(
project.path().join("src").join("lib.rs"),
"pub fn served_symbol() -> u32 { 42 }\n",
)
.expect("write source");
let handle = spawn_daemon("127.0.0.1").await.expect("spawn daemon");
let base_url = format!("http://127.0.0.1:{}", handle.port);
let http = authed_client(&handle);
let opened = http
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "status-proxy".to_string(),
pid: Some(std::process::id()),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let client = DaemonSessionClient::new_for_test(
base_url.clone(),
opened.project_id.clone(),
opened.session_id.clone(),
opened.project_name.clone(),
)
.with_project_root(project.path().to_path_buf());
let server = crate::protocol::SymForgeServer::new_daemon_proxy(client);
let indexed = server
.index_folder(Parameters(IndexFolderInput {
path: project.path().display().to_string(),
idempotency_key: None,
add: None,
}))
.await;
assert!(
indexed.starts_with("Indexed "),
"daemon proxy index_folder must succeed, got: {indexed}"
);
let search_input = serde_json::from_value(serde_json::json!({
"query": "served_symbol"
}))
.expect("search_symbols input");
let query = server.search_symbols(Parameters(search_input)).await;
assert!(
query.contains("served_symbol"),
"proxied query must serve the indexed symbol from the warm daemon, got: {query}"
);
let status_result = server
.status_stel_tool(Parameters(crate::stel::StelStatusRequest::default()))
.await
.expect("status dispatch");
let serialized = serde_json::to_value(&status_result).expect("serialize status result");
let status_body = serialized["content"][0]["text"]
.as_str()
.expect("status result text")
.to_string();
assert!(
status_body.contains("index_ready: true"),
"status must report the served daemon index as ready (FR-006), got:\n{status_body}"
);
assert!(
!status_body.contains("index_files: 0"),
"status must report non-zero index_files for the served index (SC-002), got:\n{status_body}"
);
assert!(
status_body.contains("index_files: 1\n"),
"status must report exactly the single indexed file from the daemon, got:\n{status_body}"
);
assert_eq!(
server.index().published_state().file_count,
0,
"front-end self.index must remain empty — status must source from the daemon"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&daemon_home.path().join(LEGACY_DAEMON_PORT_FILE)).await;
}
#[tokio::test]
async fn test_symforge_edit_apply_commits_through_daemon_proxy() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _home_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let _surface_guard = EnvVarGuard::set_str("SYMFORGE_SURFACE", "compact");
let project = project_dir("symforge-edit-proxy");
let file_path = project.path().join("src").join("lib.rs");
std::fs::write(&file_path, "pub fn proxy_edit() -> u32 { 1 }\n").expect("write source");
let handle = spawn_daemon("127.0.0.1").await.expect("spawn daemon");
let base_url = format!("http://127.0.0.1:{}", handle.port);
let http = authed_client(&handle);
let opened = http
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "edit-proxy".to_string(),
pid: Some(std::process::id()),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let client = DaemonSessionClient::new_for_test(
base_url.clone(),
opened.project_id.clone(),
opened.session_id.clone(),
opened.project_name.clone(),
)
.with_project_root(project.path().to_path_buf());
let server = crate::protocol::SymForgeServer::new_daemon_proxy(client);
let indexed = server
.index_folder(Parameters(IndexFolderInput {
path: project.path().display().to_string(),
idempotency_key: None,
add: None,
}))
.await;
assert!(
indexed.starts_with("Indexed "),
"daemon proxy index_folder must succeed, got: {indexed}"
);
assert_eq!(
server.index().published_state().file_count,
0,
"front-end proxy index is intentionally empty"
);
let result = server
.symforge_edit_facade_tool(Parameters(crate::stel::StelEditRequest {
path: "src/lib.rs".to_string(),
symbol: Some("proxy_edit".to_string()),
body: Some("pub fn proxy_edit() -> u32 { 2 }".to_string()),
apply: Some(true),
..Default::default()
}))
.await
.expect("symforge_edit dispatch");
let serialized = serde_json::to_value(&result).expect("serialize symforge_edit result");
let body = serialized["content"][0]["text"]
.as_str()
.expect("symforge_edit result text");
assert!(
!body.starts_with("Index not loaded."),
"daemon-proxy apply must not inspect the empty front-end index:\n{body}"
);
let on_disk = std::fs::read_to_string(&file_path).expect("read edited file");
assert!(
on_disk.contains("{ 2 }"),
"symforge_edit apply must commit through the daemon proxy, got:\n{on_disk}\n\nbody:\n{body}"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&daemon_home.path().join(LEGACY_DAEMON_PORT_FILE)).await;
}
#[tokio::test]
async fn test_index_folder_proxy_switch_invalidates_stale_local_index() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project_a = project_dir("symforge-proxy-stale-a");
let project_b = project_dir("symforge-proxy-stale-b");
std::fs::write(
project_a.path().join("src").join("old.rs"),
"fn old_fn() {}\n",
)
.expect("write source a");
std::fs::write(
project_b.path().join("src").join("new.rs"),
"fn new_fn() {}\n",
)
.expect("write source b");
let handle = spawn_daemon("127.0.0.1").await.expect("spawn daemon");
let base_url = format!("http://127.0.0.1:{}", handle.port);
let http = authed_client(&handle);
let opened = http
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "regression".to_string(),
pid: Some(std::process::id()),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let client = DaemonSessionClient::new_for_test(
base_url.clone(),
opened.project_id.clone(),
opened.session_id.clone(),
opened.project_name.clone(),
)
.with_project_root(project_a.path().to_path_buf());
let server = crate::protocol::SymForgeServer::new_daemon_proxy(client);
server.index.add_file(
"src/old.rs".to_string(),
crate::live_index::store::IndexedFile {
relative_path: "src/old.rs".to_string(),
language: crate::domain::index::LanguageId::Rust,
classification: crate::domain::FileClassification::for_code_path("src/old.rs"),
content: b"fn old_fn() {}".to_vec(),
symbols: vec![],
parse_status: crate::live_index::store::ParseStatus::Parsed,
parse_diagnostic: None,
byte_len: 14,
content_hash: "old-hash".to_string(),
references: vec![],
alias_map: std::collections::HashMap::new(),
mtime_secs: 0,
},
);
assert_eq!(
server.index.published_state().file_count,
1,
"precondition: stale local index holds the OLD project"
);
let result = server
.index_folder(Parameters(IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: None,
add: None,
}))
.await;
assert!(
result.starts_with("Indexed "),
"daemon proxy index_folder should report success, got: {result}"
);
assert_eq!(
server.index.published_state().file_count,
0,
"stale local index must be reset to empty after a proxy project switch, got: {result}"
);
assert!(
server.index.read().get_file("src/old.rs").is_none(),
"OLD-project file must be unreachable from the local index after switch"
);
let switched_root = server.capture_repo_root().expect("repo root after switch");
assert_eq!(
switched_root,
project_b.path().to_path_buf(),
"repo_root must point at the new project after a proxy switch"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&daemon_home.path().join(LEGACY_DAEMON_PORT_FILE)).await;
}
#[tokio::test]
async fn test_retarget_updates_bound_root_in_status_and_symforge_surfaces() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let _surface_guard = EnvVarGuard::set_str("SYMFORGE_SURFACE", "compact");
let project_a = project_dir("symforge-retarget-root-a");
let project_b = project_dir("symforge-retarget-root-b");
std::fs::write(
project_a.path().join("src").join("lib.rs"),
"pub fn alpha_symbol() -> u32 { 1 }\n",
)
.expect("write source a");
std::fs::write(
project_b.path().join("src").join("lib.rs"),
"pub fn beta_symbol() -> u32 { 2 }\n",
)
.expect("write source b");
let handle = spawn_daemon("127.0.0.1").await.expect("spawn daemon");
let base_url = format!("http://127.0.0.1:{}", handle.port);
let http = authed_client(&handle);
let opened = http
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "retarget-root".to_string(),
pid: Some(std::process::id()),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let client = DaemonSessionClient::new_for_test(
base_url.clone(),
opened.project_id.clone(),
opened.session_id.clone(),
opened.project_name.clone(),
)
.with_project_root(project_a.path().to_path_buf());
let server = crate::protocol::SymForgeServer::new_daemon_proxy(client);
let root_a_norm = project_a.path().display().to_string().replace('\\', "/");
let status_before =
server.render_stel_status_body(&crate::stel::StelStatusRequest::default());
assert!(
status_before.contains(&format!("project_root: {root_a_norm}")),
"pre-retarget status must surface project A root, got:\n{status_before}"
);
let indexed = server
.index_folder(Parameters(IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: None,
add: None,
}))
.await;
assert!(
indexed.starts_with("Indexed "),
"daemon proxy retarget must succeed, got: {indexed}"
);
let switched = server
.capture_repo_root()
.expect("repo root after retarget");
assert_eq!(
switched,
project_b.path().to_path_buf(),
"repo_root must point at project B after retarget"
);
let root_b_norm = project_b.path().display().to_string().replace('\\', "/");
let status_after =
server.render_stel_status_body(&crate::stel::StelStatusRequest::default());
assert!(
status_after.contains(&format!("project_root: {root_b_norm}")),
"post-retarget status must surface project B root, got:\n{status_after}"
);
assert!(
!status_after.contains(&format!("project_root: {root_a_norm}")),
"stale project A root must NOT survive in status after retarget, got:\n{status_after}"
);
let symforge_input = serde_json::from_value(serde_json::json!({
"query": "find beta_symbol"
}))
.expect("symforge facade input");
let symforge_result = server
.symforge_facade_tool(Parameters(symforge_input))
.await
.expect("symforge facade dispatch");
let serialized = serde_json::to_value(&symforge_result).expect("serialize symforge result");
let symforge_body = serialized["content"][0]["text"]
.as_str()
.expect("symforge result text")
.to_string();
assert!(
symforge_body.contains(&format!("project_root: {root_b_norm}")),
"symforge envelope must surface the bound project B root, got:\n{symforge_body}"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&daemon_home.path().join(LEGACY_DAEMON_PORT_FILE)).await;
}
#[tokio::test]
async fn test_index_folder_idempotency_replays_same_key_same_request_in_daemon_route() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project_a = project_dir("symforge-daemon-idempotency-a");
let project_b = project_dir("symforge-daemon-idempotency-b");
std::fs::write(
project_a.path().join("src").join("old.rs"),
"fn old_fn() {}\n",
)
.expect("write source a");
std::fs::write(
project_b.path().join("src").join("new.rs"),
"fn new_fn() {}\n",
)
.expect("write source b");
let handle = spawn_daemon("127.0.0.1").await.expect("spawn daemon");
let client = authed_client(&handle);
let base_url = format!("http://127.0.0.1:{}", handle.port);
let opened = client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "codex".to_string(),
pid: Some(56),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let tool_url = format!(
"{base_url}/v1/sessions/{}/tools/index_folder",
opened.session_id
);
let first = client
.post(&tool_url)
.json(&IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: Some("daemon-replay-key".to_string()),
add: None,
})
.send()
.await
.expect("first index request")
.error_for_status()
.expect("first index status")
.text()
.await
.expect("first index body");
assert!(
first.starts_with("Indexed 1 files"),
"first daemon idempotent index_folder should index once, got: {first}"
);
std::fs::write(
project_b.path().join("src").join("second.rs"),
"fn second_fn() {}\n",
)
.expect("write second source b");
let replay = client
.post(&tool_url)
.json(&IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: Some("daemon-replay-key".to_string()),
add: None,
})
.send()
.await
.expect("replay index request")
.error_for_status()
.expect("replay index status")
.text()
.await
.expect("replay index body");
assert_eq!(
replay, first,
"daemon special route must replay stored output for same key and canonical request"
);
let conflict = client
.post(&tool_url)
.json(&IndexFolderInput {
path: project_a.path().display().to_string(),
idempotency_key: Some("daemon-replay-key".to_string()),
add: None,
})
.send()
.await
.expect("conflict index request")
.error_for_status()
.expect("conflict index status")
.text()
.await
.expect("conflict index body");
assert!(
conflict.contains("Idempotency conflict"),
"daemon special route must reject same key with different request, got: {conflict}"
);
assert!(
!conflict.starts_with("Indexed "),
"daemon conflict must not report synthetic indexing success: {conflict}"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&daemon_home.path().join(LEGACY_DAEMON_PORT_FILE)).await;
}
#[tokio::test]
async fn test_analyze_file_impact_uses_session_project_root_not_process_cwd() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project = project_dir("symforge-daemon-impact-root");
let outside = TempDir::new().expect("outside cwd");
let source_path = project.path().join("src").join("lib.rs");
std::fs::write(&source_path, "pub fn old_name() {}\n").expect("write initial source");
let handle = spawn_daemon("127.0.0.1").await.expect("spawn daemon");
let client = authed_client(&handle);
let base_url = format!("http://127.0.0.1:{}", handle.port);
let opened = client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "codex".to_string(),
pid: Some(4242),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
std::fs::write(&source_path, "pub fn new_name() {}\n").expect("write updated source");
let _cwd_guard = CwdGuard::set(outside.path());
let impact = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/analyze_file_impact",
opened.session_id
))
.json(&serde_json::json!({
"path": "src/lib.rs"
}))
.send()
.await
.expect("impact request")
.error_for_status()
.expect("impact status")
.text()
.await
.expect("impact body");
assert!(
impact.contains("new_name"),
"impact analysis should read from the session project root, got: {impact}"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&daemon_home.path().join(LEGACY_DAEMON_PORT_FILE)).await;
}
#[test]
fn test_concurrent_open_same_project_no_panic() {
use std::sync::{Arc, Barrier};
let project = project_dir("symforge-conc-same");
std::fs::write(project.path().join("src").join("main.rs"), "fn main() {}\n")
.expect("write source");
let project_root = project.path().display().to_string();
let state = Arc::new(DaemonState::new());
let barrier = Arc::new(Barrier::new(2));
let handles: Vec<_> = (0..2)
.map(|i| {
let state = Arc::clone(&state);
let barrier = Arc::clone(&barrier);
let root = project_root.clone();
std::thread::spawn(move || {
barrier.wait();
state.open_project_session(OpenProjectRequest {
project_root: root,
client_name: format!("client-{i}"),
pid: None,
})
})
})
.collect();
for handle in handles {
handle
.join()
.expect("thread panicked")
.expect("open_project_session failed");
}
let projects = state.list_projects();
assert_eq!(projects.len(), 1, "exactly 1 project instance expected");
assert_eq!(
state.health().session_count,
2,
"exactly 2 sessions expected"
);
let project_id = &projects[0].project_id;
let projects_lock = state.projects.read();
let instance = projects_lock.get(project_id).expect("project must exist");
assert_eq!(
instance.activation_state,
ActivationState::Active,
"project must be Active after concurrent opens"
);
}
#[test]
fn test_concurrent_open_different_projects() {
use std::sync::{Arc, Barrier};
let project_a = project_dir("symforge-conc-diff-a");
std::fs::write(
project_a.path().join("src").join("main.rs"),
"fn main() {}\n",
)
.expect("write source a");
let project_b = project_dir("symforge-conc-diff-b");
std::fs::write(
project_b.path().join("src").join("main.rs"),
"fn main() {}\n",
)
.expect("write source b");
let root_a = project_a.path().display().to_string();
let root_b = project_b.path().display().to_string();
let state = Arc::new(DaemonState::new());
let barrier = Arc::new(Barrier::new(2));
let roots = [root_a, root_b];
let handles: Vec<_> = roots
.iter()
.enumerate()
.map(|(i, root)| {
let state = Arc::clone(&state);
let barrier = Arc::clone(&barrier);
let root = root.clone();
std::thread::spawn(move || {
barrier.wait();
state.open_project_session(OpenProjectRequest {
project_root: root,
client_name: format!("client-{i}"),
pid: None,
})
})
})
.collect();
let responses: Vec<_> = handles
.into_iter()
.map(|h| h.join().expect("thread panicked").expect("open failed"))
.collect();
assert_ne!(
responses[0].project_id, responses[1].project_id,
"two distinct projects expected"
);
assert_eq!(
state.list_projects().len(),
2,
"exactly 2 project instances expected"
);
}
#[test]
fn test_open_close_race_no_panic() {
use std::sync::{Arc, Barrier};
let project = project_dir("symforge-conc-race");
std::fs::write(project.path().join("src").join("main.rs"), "fn main() {}\n")
.expect("write source");
let project_root = project.path().display().to_string();
let state = Arc::new(DaemonState::new());
let first = state
.open_project_session(OpenProjectRequest {
project_root: project_root.clone(),
client_name: "racer-first".to_string(),
pid: None,
})
.expect("first session");
let first_session_id = first.session_id.clone();
let barrier = Arc::new(Barrier::new(2));
let state_a = Arc::clone(&state);
let barrier_a = Arc::clone(&barrier);
let root_a = project_root.clone();
let open_handle = std::thread::spawn(move || {
barrier_a.wait();
state_a.open_project_session(OpenProjectRequest {
project_root: root_a,
client_name: "racer-open".to_string(),
pid: None,
})
});
let state_b = Arc::clone(&state);
let barrier_b = Arc::clone(&barrier);
let close_handle = std::thread::spawn(move || {
barrier_b.wait();
state_b.close_session(&first_session_id)
});
open_handle
.join()
.expect("open thread panicked")
.expect("open failed");
close_handle.join().expect("close thread panicked");
}
#[test]
fn test_discarded_instance_no_leaked_tasks() {
use std::sync::{Arc, Barrier};
let project = project_dir("symforge-conc-3way");
std::fs::write(project.path().join("src").join("main.rs"), "fn main() {}\n")
.expect("write source");
let project_root = project.path().display().to_string();
let state = Arc::new(DaemonState::new());
let barrier = Arc::new(Barrier::new(3));
let handles: Vec<_> = (0..3)
.map(|i| {
let state = Arc::clone(&state);
let barrier = Arc::clone(&barrier);
let root = project_root.clone();
std::thread::spawn(move || {
barrier.wait();
state.open_project_session(OpenProjectRequest {
project_root: root,
client_name: format!("racer-{i}"),
pid: None,
})
})
})
.collect();
for handle in handles {
handle
.join()
.expect("thread panicked")
.expect("open_project_session failed");
}
let projects = state.list_projects();
assert_eq!(projects.len(), 1, "exactly 1 project instance expected");
assert_eq!(
state.health().session_count,
3,
"exactly 3 sessions expected"
);
let project_id = &projects[0].project_id;
let projects_lock = state.projects.read();
let instance = projects_lock.get(project_id).expect("project must exist");
assert_eq!(
instance.activation_state,
ActivationState::Active,
"project must be Active"
);
}
#[tokio::test]
async fn test_stale_start_lock_is_removed() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let lock_path = daemon_home.path().join(daemon_start_lock_file_name());
let file = std::fs::File::create(&lock_path).expect("create lock");
let old_time = std::time::SystemTime::now() - std::time::Duration::from_secs(60);
let times = std::fs::FileTimes::new().set_modified(old_time);
file.set_times(times).expect("set file times");
drop(file);
let result = try_acquire_start_lock().expect("should not error");
assert!(
result.is_some(),
"stale lock (>30s old) should be removed and lock acquired"
);
drop(result);
}
#[tokio::test]
async fn test_fresh_start_lock_blocks_acquisition() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let lock_path = daemon_home.path().join(daemon_start_lock_file_name());
std::fs::write(&lock_path, "").expect("create lock");
let result = try_acquire_start_lock().expect("should not error");
assert!(
result.is_none(),
"fresh lock (<30s old) should block acquisition"
);
let _ = std::fs::remove_file(&lock_path);
}
#[tokio::test]
async fn test_cleanup_daemon_files_removes_start_lock() {
let _env_lock = env_lock().await;
let dir = TempDir::new().expect("temp dir");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", dir.path());
let port_file = dir.path().join(LEGACY_DAEMON_PORT_FILE);
let pid_file = dir.path().join(LEGACY_DAEMON_PID_FILE);
let lock_file = dir.path().join(LEGACY_DAEMON_START_LOCK_FILE);
std::fs::write(&port_file, "12345").expect("write port");
std::fs::write(&pid_file, "99999").expect("write pid");
std::fs::write(&lock_file, "").expect("write lock");
cleanup_daemon_files();
assert!(!port_file.exists(), "cleanup removes port file");
assert!(!pid_file.exists(), "cleanup removes pid file");
assert!(!lock_file.exists(), "cleanup removes start lock file");
}
#[tokio::test]
async fn test_runtime_cleanup_preserves_start_lock() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let port_file = daemon_home.path().join(LEGACY_DAEMON_PORT_FILE);
let pid_file = daemon_home.path().join(LEGACY_DAEMON_PID_FILE);
let lock_file = daemon_home.path().join(LEGACY_DAEMON_START_LOCK_FILE);
std::fs::write(&port_file, "12345").expect("write port");
std::fs::write(&pid_file, "99999").expect("write pid");
std::fs::write(&lock_file, "").expect("write lock");
cleanup_daemon_runtime_files();
assert!(!port_file.exists(), "runtime cleanup removes port file");
assert!(!pid_file.exists(), "runtime cleanup removes pid file");
assert!(
lock_file.exists(),
"runtime cleanup must not release another process' start lock"
);
}
#[tokio::test]
async fn test_corrupt_port_file_does_not_block_daemon_selection() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
std::fs::write(
daemon_home.path().join(LEGACY_DAEMON_PORT_FILE),
"not-a-port",
)
.expect("write corrupt port");
let identity = current_daemon_identity();
let selected = daemon_port_if_compatible(&identity)
.await
.expect("corrupt port should be ignored, not fatal");
assert_eq!(selected, None);
}
}