use std::net::SocketAddr;
use std::sync::Arc;
use parking_lot::Mutex;
use super::api_keys::ApiKeyStore;
use super::auth::{AuthConfig, AuthLayerState};
use super::{ServerRuntime, admin, mcp_http};
use crate::domain::{
ControlStateDir, RootCandidateSource, RootRequestMode, RootResolution, StatePlacement,
};
use crate::live_index::{LiveIndex, SharedIndex};
use crate::protocol::SymForgeServer;
use crate::sidecar::governor::RequestGovernor;
use crate::stel::ledger_store::StelLedgerStore;
use crate::watcher::WatcherInfo;
pub const DEFAULT_LISTEN: &str = "127.0.0.1:8787";
#[derive(Debug)]
pub struct ServeArgs {
pub listen: String,
pub explicit_listen: bool,
pub api_key: Option<String>,
pub api_key_env: Option<String>,
pub bound_addr_tx: Option<std::sync::mpsc::SyncSender<Result<SocketAddr, String>>>,
pub workspace_root: Option<std::path::PathBuf>,
pub projects: Vec<String>,
pub allow_index_folder: bool,
}
impl Default for ServeArgs {
fn default() -> Self {
Self {
listen: DEFAULT_LISTEN.to_string(),
explicit_listen: false,
api_key: None,
api_key_env: None,
bound_addr_tx: None,
workspace_root: None,
projects: Vec::new(),
allow_index_folder: false,
}
}
}
pub fn resolve_api_key(api_key: Option<&str>, api_key_env: Option<&str>) -> Option<String> {
if let Some(key) = api_key
&& !key.is_empty()
{
return Some(key.to_string());
}
if let Some(var) = api_key_env
&& let Ok(value) = std::env::var(var)
&& !value.is_empty()
{
return Some(value);
}
None
}
pub fn enforce_api_key_source_policy(
api_key: Option<&str>,
is_loopback: bool,
) -> Result<(), super::auth::AuthStartupError> {
let inline_present = matches!(api_key, Some(key) if !key.is_empty());
if !inline_present {
return Ok(());
}
if !is_loopback {
return Err(super::auth::AuthStartupError::InlineKeyOnNonLoopback);
}
let msg = "WARNING: --api-key was passed inline; it is visible in process listings \
(ps / Task Manager). Prefer --api-key-env <VAR> so the secret stays out of argv.";
tracing::warn!("{msg}");
eprintln!("{msg}");
Ok(())
}
pub fn is_loopback_addr(addr: &SocketAddr) -> bool {
let ip = match addr.ip() {
std::net::IpAddr::V6(v6) => v6
.to_ipv4_mapped()
.map(std::net::IpAddr::V4)
.unwrap_or(std::net::IpAddr::V6(v6)),
other => other,
};
ip.is_loopback()
}
pub fn bind_listener(addr: SocketAddr) -> std::io::Result<tokio::net::TcpListener> {
let domain = if addr.is_ipv4() {
socket2::Domain::IPV4
} else {
socket2::Domain::IPV6
};
let socket = socket2::Socket::new(domain, socket2::Type::STREAM, Some(socket2::Protocol::TCP))?;
#[cfg(target_os = "linux")]
socket.set_reuse_address(true)?;
socket.set_nonblocking(true)?;
socket.bind(&addr.into())?;
socket.listen(1024)?;
let std_listener: std::net::TcpListener = socket.into();
tokio::net::TcpListener::from_std(std_listener)
}
pub(crate) fn operator_port_candidates() -> impl Iterator<Item = u16> {
const SPREAD: [u16; 6] = [8080, 8088, 8181, 8585, 8686, 8989];
SPREAD
.into_iter()
.chain(8000u16..=8999)
.chain(5000u16..=5999)
}
pub fn probe_free_listener(
preferred: Option<SocketAddr>,
) -> std::io::Result<tokio::net::TcpListener> {
if let Some(addr) = preferred {
if addr.port() == 0 {
return bind_listener(addr);
}
if let Ok(listener) = bind_listener(addr) {
return Ok(listener);
}
}
for port in operator_port_candidates() {
let addr = SocketAddr::new(std::net::IpAddr::V4(std::net::Ipv4Addr::LOCALHOST), port);
if let Ok(listener) = bind_listener(addr) {
return Ok(listener);
}
}
Err(std::io::Error::new(
std::io::ErrorKind::AddrInUse,
"no free operator port available in 8000-8999 or 5000-5999",
))
}
pub fn probe_free_port(preferred: Option<SocketAddr>) -> std::io::Result<SocketAddr> {
let listener = probe_free_listener(preferred)?;
listener.local_addr()
}
#[derive(Debug, thiserror::Error)]
pub enum ServeError {
#[error("invalid --listen address {addr:?}: {source}")]
InvalidListen {
addr: String,
#[source]
source: std::net::AddrParseError,
},
#[error(transparent)]
Startup(#[from] super::auth::AuthStartupError),
#[error("{0}")]
ToolAllowList(String),
#[error("{0}")]
Projects(String),
#[error("failed to bind {addr}: {source}")]
Bind {
addr: SocketAddr,
#[source]
source: std::io::Error,
},
#[error("failed to load project index for serving: {source}")]
IndexLoad {
#[source]
source: anyhow::Error,
},
#[error("operator server error: {source}")]
Serve {
#[source]
source: std::io::Error,
},
}
type LoadedServeIndex = (
SharedIndex,
Option<std::path::PathBuf>,
Option<StatePlacement>,
Option<std::collections::HashMap<String, u64>>,
Option<Arc<crate::live_index::index_lifecycle::activation::ProjectSourceAuthority>>,
);
fn load_serve_index(
workspace_root: Option<&std::path::Path>,
) -> Result<LoadedServeIndex, ServeError> {
let discovered = match workspace_root {
Some(root) => Some(root.to_path_buf()),
None => crate::discovery::find_project_root(),
};
let Some(root) = discovered else {
return Ok((LiveIndex::empty(), None, None, None, None));
};
let RootResolution::Bound(binding) = crate::discovery::resolve_root_candidate(
&root,
RootCandidateSource::LaunchCwd,
RootRequestMode::Automatic,
) else {
return Ok((LiveIndex::empty(), None, None, None, None));
};
load_bound_serve_index(binding)
}
fn load_bound_serve_index(
binding: crate::domain::RootBinding,
) -> Result<LoadedServeIndex, ServeError> {
let state_placement = crate::discovery::resolve_state_placement(&binding);
let root = binding.canonical_root;
let admission = crate::live_index::index_lifecycle::activation::admit_project(
crate::live_index::index_lifecycle::process_runtime::SurfaceKind::Serve,
&root,
&binding.root_id.0,
binding.access_mode,
&state_placement,
)
.map_err(|refusal| ServeError::IndexLoad {
source: anyhow::anyhow!("project admission refused: {refusal:?}"),
})?;
let source_authority =
crate::live_index::index_lifecycle::activation::project_source_authority(&root);
let admitted_physical_root = admission
.binding()
.map_err(|refusal| ServeError::IndexLoad {
source: anyhow::anyhow!("project admission retired: {refusal:?}"),
})?
.physical_root();
if source_authority.admission_binding().physical_root() != admitted_physical_root {
return Err(ServeError::IndexLoad {
source: anyhow::anyhow!("admitted serve source changed before snapshot restore"),
});
}
if let Some(snapshot) =
crate::live_index::persist::load_snapshot_bound(&root, &state_placement, &source_authority)
.map_err(|refusal| ServeError::IndexLoad {
source: anyhow::anyhow!("admitted snapshot load refused: {refusal:?}"),
})?
{
let file_count = snapshot.files.len();
let snapshot_mtimes: std::collections::HashMap<String, u64> = snapshot
.files
.iter()
.map(|(path, file)| (path.clone(), file.mtime_secs))
.collect();
let (live, code_signals) =
crate::live_index::persist::snapshot_to_live_index_with_code_signals_bound(
snapshot,
&root,
&source_authority,
)
.map_err(|refusal| ServeError::IndexLoad {
source: anyhow::anyhow!("admitted snapshot source refused: {refusal:?}"),
})?;
tracing::info!(
files = file_count,
load_source = ?live.load_source(),
snapshot_verify_state = ?live.snapshot_verify_state(),
"serve: loaded serialized index from .symforge/index.bin"
);
let shared = crate::live_index::SharedIndexHandle::shared_restored_for_state_placement_with_code_signals(
live,
&root,
&state_placement,
code_signals,
);
return Ok((
shared,
Some(root),
Some(state_placement),
Some(snapshot_mtimes),
Some(source_authority),
));
}
let index = LiveIndex::load_for_state_placement(&root, &state_placement)
.map_err(|source| ServeError::IndexLoad { source })?;
Ok((
index,
Some(root),
Some(state_placement),
None,
Some(source_authority),
))
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ProjectSpec {
pub alias: String,
pub path: std::path::PathBuf,
}
pub fn parse_project_spec(raw: &str) -> Result<ProjectSpec, String> {
let Some((alias, path)) = raw.split_once('=') else {
return Err(format!("--project {raw:?}: expected ALIAS=PATH"));
};
let alias_problem = if alias.is_empty() {
Some("must not be empty")
} else if alias.chars().any(char::is_whitespace) {
Some("must not contain whitespace")
} else if alias.contains(',') {
Some("must not contain a comma (aliases are listed comma-separated)")
} else if alias.contains('/') || alias.contains('\\') {
Some("must not contain / or \\ (an alias is a name, not a path)")
} else if alias == "*" {
Some("must not be * (it selects every project)")
} else if alias.chars().any(char::is_control) {
Some("must not contain control characters")
} else {
None
};
if let Some(problem) = alias_problem {
return Err(format!("--project {raw:?}: the alias {problem}"));
}
if path.is_empty() {
return Err(format!(
"--project {raw:?}: expected ALIAS=PATH, PATH is empty"
));
}
Ok(ProjectSpec {
alias: alias.to_string(),
path: std::path::PathBuf::from(path),
})
}
pub fn parse_project_specs(
raw: &[String],
allow_index_folder: bool,
) -> Result<Vec<ProjectSpec>, String> {
let specs = raw
.iter()
.map(|entry| parse_project_spec(entry))
.collect::<Result<Vec<_>, _>>()?;
let mut seen = std::collections::HashSet::new();
if let Some(duplicate) = specs
.iter()
.find(|spec| !seen.insert(spec.alias.to_lowercase()))
{
return Err(format!(
"--project: duplicate alias {:?} (aliases are compared case-insensitively)",
duplicate.alias
));
}
if allow_index_folder && specs.len() > 1 {
return Err(
"--allow-index-folder lets a client replace the served repository, so it is only \
accepted with at most one --project entry"
.to_string(),
);
}
Ok(specs)
}
fn refuse_overlapping_roots(
bindings: &[(String, crate::domain::RootBinding)],
) -> Result<(), ServeError> {
for (index, (alias, binding)) in bindings.iter().enumerate() {
for (other_alias, other) in &bindings[index + 1..] {
let (root, other_root) = (&binding.canonical_root, &other.canonical_root);
let problem = if root == other_root {
format!(
"--project {alias} and {other_alias} name the same repository ({})",
root.display()
)
} else if other_root.starts_with(root) {
format!(
"--project {other_alias} ({}) is inside --project {alias} ({})",
other_root.display(),
root.display()
)
} else if root.starts_with(other_root) {
format!(
"--project {alias} ({}) is inside --project {other_alias} ({})",
root.display(),
other_root.display()
)
} else {
continue;
};
return Err(ServeError::Projects(format!(
"{problem}; list repositories that neither equal nor contain each other"
)));
}
}
Ok(())
}
fn bind_project_spec(spec: &ProjectSpec) -> Result<crate::domain::RootBinding, ServeError> {
let refuse = |why: String| {
ServeError::Projects(format!(
"--project {}={}: {why}",
spec.alias,
spec.path.display()
))
};
match crate::protocol::tools::resolve_explicit_index_folder_root(&spec.path) {
RootResolution::Bound(binding) => Ok(binding),
RootResolution::Unbound { reason, .. } => Err(refuse(match reason {
crate::domain::UnboundReason::Refused(_) if !spec.path.exists() => {
"the path does not exist".to_string()
}
crate::domain::UnboundReason::Refused(reason) => {
format!("the path cannot be served ({})", reason.code())
}
other => format!("the path cannot be served ({other:?})"),
})),
}
}
fn build_serve_runtime(
repos: Vec<LoadedRepo>,
allow_index_folder: bool,
fixed_roots: Option<crate::worktree::ServeRoots>,
auth: AuthConfig,
) -> ServerRuntime {
let first_index = Arc::clone(&repos[0].index);
let first_state_dir = repos[0]
.state_placement
.as_ref()
.and_then(|placement| placement.directory())
.cloned();
let mut served = Vec::with_capacity(repos.len());
let mut first_ledger = None;
for repo in repos {
let (server, ledger) = build_repo_server(repo);
if first_ledger.is_none() {
first_ledger = Some(ledger);
}
served.push(server);
}
let phase = std::time::Instant::now();
let key_store: Option<Arc<ApiKeyStore>> = first_state_dir
.as_ref()
.map(|state_dir| Arc::new(ApiKeyStore::open(state_dir)));
tracing::info!("serve: runtime/key store in {:?}", phase.elapsed());
let mut front = served[0].server.clone();
front.serve_projects = Some(Arc::new(
crate::protocol::serve_projects::ServeProjects::new(
served,
allow_index_folder,
fixed_roots,
),
));
let protocol = Arc::new(front);
let governor = Arc::new(RequestGovernor::new());
let runtime_store = first_ledger.flatten().map(|store| (*store).clone());
let phase = std::time::Instant::now();
let mut runtime =
ServerRuntime::build_runtime(first_index, protocol, governor, auth, runtime_store);
if let Some(store) = key_store {
runtime = runtime.with_key_store(store);
}
tracing::info!("serve: runtime/server runtime in {:?}", phase.elapsed());
runtime
}
struct LoadedRepo {
alias: String,
index: SharedIndex,
repo_root: Option<std::path::PathBuf>,
state_placement: Option<StatePlacement>,
}
fn build_repo_server(
repo: LoadedRepo,
) -> (
crate::protocol::serve_projects::ServedRepo,
Option<Arc<StelLedgerStore>>,
) {
let project_state_dir = repo
.state_placement
.as_ref()
.and_then(|placement| placement.directory());
let phase = std::time::Instant::now();
let ledger_store: Option<Arc<StelLedgerStore>> = project_state_dir.map(|state_dir| {
Arc::new(StelLedgerStore::open(
state_dir,
format!("serve-{}", std::process::id()),
))
});
tracing::info!("serve: runtime/ledger store in {:?}", phase.elapsed());
let watcher_info = Arc::new(Mutex::new(WatcherInfo::default()));
let phase = std::time::Instant::now();
let mut server = SymForgeServer::new_with_state_placement(
Arc::clone(&repo.index),
repo.alias.clone(),
Arc::clone(&watcher_info),
repo.repo_root.clone(),
repo.state_placement,
None,
);
tracing::info!("serve: runtime/protocol server in {:?}", phase.elapsed());
if let Some(store) = ledger_store.as_ref() {
server = server.with_stel_ledger_store(Arc::clone(store));
}
if let Some(root) = repo.repo_root {
let handle = crate::watcher::restart_watcher(root, repo.index, watcher_info, None);
server.watcher_handle.lock().replace(handle);
}
(
crate::protocol::serve_projects::ServedRepo {
alias: repo.alias,
server,
},
ledger_store,
)
}
pub async fn run(args: ServeArgs) -> Result<(), ServeError> {
crate::live_index::index_lifecycle::activation::activate_surface(
crate::live_index::index_lifecycle::process_runtime::SurfaceKind::Serve,
);
match crate::protocol::surface_probe::check_tool_allow_list() {
Ok(problems) if problems.is_empty() => {}
Ok(problems) => return Err(ServeError::ToolAllowList(problems.join("; "))),
Err(fatal) => return Err(ServeError::ToolAllowList(fatal)),
}
let api_key = resolve_api_key(args.api_key.as_deref(), args.api_key_env.as_deref());
let auth = AuthConfig::new(api_key);
let addr: SocketAddr = args
.listen
.parse()
.map_err(|source| ServeError::InvalidListen {
addr: args.listen.clone(),
source,
})?;
let is_loopback = is_loopback_addr(&addr);
enforce_api_key_source_policy(args.api_key.as_deref(), is_loopback)?;
auth.refuse_to_start(is_loopback)?;
let specs = parse_project_specs(&args.projects, args.allow_index_folder)
.map_err(ServeError::Projects)?;
let bindings = specs
.iter()
.map(|spec| bind_project_spec(spec).map(|binding| (spec.alias.clone(), binding)))
.collect::<Result<Vec<_>, _>>()?;
refuse_overlapping_roots(&bindings)?;
let fixed_roots = (!bindings.is_empty()).then(|| {
Arc::new(
bindings
.iter()
.map(|(alias, binding)| (alias.clone(), binding.canonical_root.clone()))
.collect::<Vec<_>>(),
)
});
let phase = std::time::Instant::now();
let loaded = if bindings.is_empty() {
let loaded = load_serve_index(args.workspace_root.as_deref())?;
let alias = loaded
.1
.as_ref()
.and_then(|root| root.file_name())
.and_then(|name| name.to_str())
.unwrap_or("project")
.to_string();
vec![(alias, loaded)]
} else {
bindings
.into_iter()
.map(|(alias, binding)| load_bound_serve_index(binding).map(|loaded| (alias, loaded)))
.collect::<Result<Vec<_>, _>>()?
};
tracing::info!("serve: index ready in {:?}", phase.elapsed());
let mut repos = Vec::with_capacity(loaded.len());
for (alias, (index, repo_root, state_placement, snapshot_mtimes, source_authority)) in loaded {
if let (Some(mtimes), Some(root), Some(authority)) =
(snapshot_mtimes, repo_root.clone(), source_authority)
{
let bg_index = index.clone();
tokio::spawn(async move {
crate::live_index::persist::background_verify_cancellable_bound(
bg_index,
root,
mtimes,
authority,
|| false,
)
.await;
});
}
repos.push(LoadedRepo {
alias,
index,
repo_root,
state_placement,
});
}
let control_state_dir: Option<ControlStateDir> =
crate::paths::process_control_state_placement()
.directory()
.cloned();
let phase = std::time::Instant::now();
let runtime = build_serve_runtime(repos, args.allow_index_folder, fixed_roots, auth.clone());
tracing::info!("serve: runtime built in {:?}", phase.elapsed());
let bind_result = if args.explicit_listen {
bind_listener(addr)
} else {
probe_free_listener(Some(addr))
}
.and_then(|listener| {
listener
.local_addr()
.map(|local_addr| (listener, local_addr))
});
let (listener, local_addr) = match bind_result {
Ok(pair) => pair,
Err(source) => {
if let Some(tx) = args.bound_addr_tx.as_ref() {
let _ = tx.try_send(Err(format!("failed to bind {addr}: {source}")));
}
return Err(ServeError::Bind { addr, source });
}
};
if let Some(tx) = args.bound_addr_tx.as_ref() {
let _ = tx.try_send(Ok(local_addr));
}
let mcp_router = mcp_http::build_mcp_router(&runtime, local_addr);
let admin_router = admin::build_admin_router(&runtime);
let merged = mcp_router.merge(admin_router);
let mut auth_state = AuthLayerState::new(auth, is_loopback);
if let Some(store) = runtime.key_store() {
auth_state = auth_state.with_key_store(Arc::clone(store));
}
let app = super::auth::apply_http_gates(merged, local_addr, auth_state);
let attach_url = format!(
"http://{host}:{port}{path}",
host = local_addr.ip(),
port = local_addr.port(),
path = mcp_http::MCP_PATH,
);
println!("{attach_url}");
if let Some(control_state_dir) = control_state_dir.as_ref() {
let state_path = crate::cli::onboarding::state_path(control_state_dir);
let mut sink = crate::cli::onboarding::StderrSink;
let detection = crate::server::aap::AapDetection::resolve();
let aap_banner = detection.detected.then(|| {
let admin_url = format!(
"http://{host}:{port}{path}",
host = local_addr.ip(),
port = local_addr.port(),
path = crate::server::admin::ADMIN_PATH,
);
crate::cli::onboarding::AapBanner {
admin_url,
embed_path_dep: crate::server::aap::embed_cargo_snippet(),
}
});
crate::cli::onboarding::maybe_show_banner_with_aap(
&state_path,
env!("CARGO_PKG_VERSION"),
&attach_url,
aap_banner.as_ref(),
&mut sink,
);
}
tracing::info!(
addr = %local_addr,
auth = if runtime.auth().requires_auth(is_loopback) { "required" } else { "loopback-open" },
"operator server listening; MCP surface mounted at {}",
mcp_http::MCP_PATH
);
let shutdown = async {
#[cfg(unix)]
{
use tokio::signal::unix::{SignalKind, signal};
let mut sigterm = signal(SignalKind::terminate()).ok();
match sigterm.as_mut() {
Some(term) => {
tokio::select! {
_ = tokio::signal::ctrl_c() => {}
_ = term.recv() => {}
}
}
None => {
let _ = tokio::signal::ctrl_c().await;
}
}
}
#[cfg(not(unix))]
{
let _ = tokio::signal::ctrl_c().await;
}
tracing::info!("shutdown signal received, stopping operator server");
};
axum::serve(listener, app)
.with_graceful_shutdown(shutdown)
.await
.map_err(|source| ServeError::Serve { source })?;
if let Some(projects) = runtime.protocol().serve_projects.as_ref() {
for repo in projects.repos() {
repo.server
.ledger_write_tracker()
.drain(std::time::Duration::from_secs(5))
.await;
}
}
tracing::info!("operator server shut down cleanly");
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
use std::sync::Mutex;
static ENV_LOCK: Mutex<()> = Mutex::new(());
#[test]
fn load_serve_index_restores_snapshot_when_present() {
let dir = tempfile::TempDir::new().expect("fixture root");
std::fs::create_dir(dir.path().join(".git")).expect("plant .git");
std::fs::write(dir.path().join("lib.rs"), "pub fn seeded() {}\n").expect("seed file");
let (cold, root, placement, mtimes, _) =
load_serve_index(Some(dir.path())).expect("cold load");
assert!(mtimes.is_none(), "no snapshot => no verify map");
let root = root.expect("root bound");
let placement = placement.expect("state placement resolved");
assert_eq!(cold.read().file_count(), 1);
crate::live_index::persist::checkpoint_shared_index(&cold, &root, &placement)
.expect("write snapshot");
let (warm, _, _, mtimes, _) = load_serve_index(Some(dir.path())).expect("warm load");
assert_eq!(
warm.read().load_source(),
crate::live_index::store::IndexLoadSource::SnapshotRestore,
"serve must rehydrate a fresh snapshot"
);
assert_eq!(warm.read().file_count(), 1);
let mtimes = mtimes.expect("snapshot restore returns the verify map");
assert!(mtimes.contains_key("lib.rs"), "mtime map keys: {mtimes:?}");
}
#[test]
fn resolve_api_key_prefers_inline_over_env() {
let _guard = ENV_LOCK.lock().unwrap();
let var = "SYMFORGE_TEST_SERVE_KEY_PREFER";
#[allow(unsafe_code)] unsafe {
std::env::set_var(var, "from_env")
};
let resolved = resolve_api_key(Some("from_inline"), Some(var));
assert_eq!(resolved.as_deref(), Some("from_inline"));
#[allow(unsafe_code)] unsafe {
std::env::remove_var(var)
};
}
#[test]
fn resolve_api_key_falls_back_to_env() {
let _guard = ENV_LOCK.lock().unwrap();
let var = "SYMFORGE_TEST_SERVE_KEY_FALLBACK";
#[allow(unsafe_code)] unsafe {
std::env::set_var(var, "from_env")
};
let resolved = resolve_api_key(None, Some(var));
assert_eq!(resolved.as_deref(), Some("from_env"));
#[allow(unsafe_code)] unsafe {
std::env::remove_var(var)
};
}
#[test]
fn resolve_api_key_none_when_unset() {
let _guard = ENV_LOCK.lock().unwrap();
let var = "SYMFORGE_TEST_SERVE_KEY_UNSET";
#[allow(unsafe_code)] unsafe {
std::env::remove_var(var)
};
assert_eq!(resolve_api_key(None, Some(var)), None);
assert_eq!(resolve_api_key(None, None), None);
assert_eq!(resolve_api_key(Some(""), None), None);
}
#[test]
fn inline_key_on_loopback_is_allowed_with_warning() {
assert!(enforce_api_key_source_policy(Some("k"), true).is_ok());
}
#[test]
fn inline_key_on_non_loopback_is_refused() {
let err = enforce_api_key_source_policy(Some("k"), false)
.expect_err("inline key on non-loopback must refuse");
assert_eq!(
err,
super::super::auth::AuthStartupError::InlineKeyOnNonLoopback
);
}
#[test]
fn no_inline_key_passes_policy_on_any_bind() {
assert!(enforce_api_key_source_policy(None, true).is_ok());
assert!(enforce_api_key_source_policy(None, false).is_ok());
assert!(enforce_api_key_source_policy(Some(""), false).is_ok());
}
#[tokio::test]
async fn run_refuses_inline_key_on_non_loopback() {
let args = ServeArgs {
listen: "0.0.0.0:8787".to_string(),
explicit_listen: true,
api_key: Some("inline-secret".to_string()),
api_key_env: None,
bound_addr_tx: None,
workspace_root: None,
..ServeArgs::default()
};
let err = run(args)
.await
.expect_err("non-loopback + inline key must refuse");
assert!(matches!(
err,
ServeError::Startup(super::super::auth::AuthStartupError::InlineKeyOnNonLoopback)
));
}
#[test]
fn is_loopback_addr_classifies_v4_and_v6() {
assert!(is_loopback_addr(&SocketAddr::new(
IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)),
8787
)));
assert!(is_loopback_addr(&SocketAddr::new(
IpAddr::V6(Ipv6Addr::LOCALHOST),
8787
)));
assert!(is_loopback_addr(
&"[::ffff:127.0.0.1]:8787"
.parse()
.expect("v4-mapped loopback parses")
));
assert!(!is_loopback_addr(&SocketAddr::new(
IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)),
8787
)));
assert!(!is_loopback_addr(&SocketAddr::new(
IpAddr::V4(Ipv4Addr::new(192, 168, 1, 10)),
8787
)));
}
#[tokio::test]
async fn run_refuses_non_loopback_without_key() {
let args = ServeArgs {
listen: "0.0.0.0:8787".to_string(),
explicit_listen: true,
api_key: None,
api_key_env: None,
bound_addr_tx: None,
workspace_root: None,
..ServeArgs::default()
};
let err = run(args)
.await
.expect_err("non-loopback + no key must refuse");
assert!(matches!(err, ServeError::Startup(_)));
}
#[tokio::test]
async fn run_refuses_an_unknown_tool_allow_list_name() {
use crate::protocol::surface_probe::SurfaceEnvVarGuard;
let _tools = SurfaceEnvVarGuard::set("SYMFORGE_TOOLS", Some("status,bogus"));
let _surface = SurfaceEnvVarGuard::set("SYMFORGE_SURFACE", None);
let args = ServeArgs {
listen: "127.0.0.1:0".to_string(),
explicit_listen: true,
api_key: None,
api_key_env: None,
bound_addr_tx: None,
workspace_root: None,
..ServeArgs::default()
};
let err = run(args).await.expect_err("unknown name must refuse");
assert!(
matches!(&err, ServeError::ToolAllowList(text) if text.contains("bogus")),
"{err}"
);
}
#[tokio::test]
async fn run_rejects_unparseable_listen() {
let args = ServeArgs {
listen: "not-an-address".to_string(),
explicit_listen: true,
api_key: Some("k".to_string()),
api_key_env: None,
bound_addr_tx: None,
workspace_root: None,
..ServeArgs::default()
};
let err = run(args).await.expect_err("bad --listen must error");
assert!(matches!(err, ServeError::InvalidListen { .. }));
}
#[test]
fn parse_project_spec_splits_at_the_first_equals() {
let spec = parse_project_spec(r"a=C:\work\x=y").expect("drive colon and = in the path");
assert_eq!(spec.alias, "a");
assert_eq!(spec.path, std::path::PathBuf::from(r"C:\work\x=y"));
assert!(
parse_project_spec(r"C:\work")
.expect_err("no =")
.contains("ALIAS=PATH")
);
for bad in [
"=p",
" a=p",
"a =p",
"my repo=p",
"a,b=p",
"a/b=p",
r"a\b=p",
"*=p",
"a=",
"a\tb=p",
] {
assert!(parse_project_spec(bad).is_err(), "{bad:?} must be refused");
}
}
#[test]
fn parse_project_specs_refuses_duplicates_and_allow_with_several() {
let list = |entries: &[&str]| entries.iter().map(|e| e.to_string()).collect::<Vec<_>>();
let duplicate = parse_project_specs(&list(&["Repo=/a", "repo=/b"]), false)
.expect_err("case-insensitive duplicate");
assert!(duplicate.contains("duplicate"), "{duplicate}");
let allow = parse_project_specs(&list(&["a=/a", "b=/b"]), true).expect_err("allow + two");
assert!(allow.contains("--allow-index-folder"), "{allow}");
assert_eq!(
parse_project_specs(&list(&["a=/a"]), true)
.expect("allow + one")
.len(),
1
);
assert!(
parse_project_specs(&[], true)
.expect("allow + none")
.is_empty()
);
}
#[tokio::test]
async fn bind_listener_binds_ephemeral_loopback_port() {
let addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
let listener = bind_listener(addr).expect("bind ephemeral loopback");
let local = listener.local_addr().expect("local_addr");
assert!(local.ip().is_loopback());
assert_ne!(local.port(), 0, "OS must assign a concrete port");
}
#[tokio::test]
async fn probe_free_port_uses_preferred_when_free() {
let scratch = bind_listener("127.0.0.1:0".parse().unwrap()).expect("scratch bind");
let preferred = scratch.local_addr().expect("local_addr");
drop(scratch);
let chosen = probe_free_port(Some(preferred)).expect("probe a free preferred port");
assert_eq!(
chosen, preferred,
"a free preferred port is honored exactly"
);
}
fn occupy_exclusive() -> (std::net::TcpListener, SocketAddr) {
let listener =
std::net::TcpListener::bind("127.0.0.1:0").expect("exclusive occupy a loopback port");
let addr = listener.local_addr().expect("local_addr");
(listener, addr)
}
fn in_operator_range(port: u16) -> bool {
(8000..=8999).contains(&port) || (5000..=5999).contains(&port)
}
#[tokio::test]
async fn probe_free_port_falls_back_to_operator_range_when_preferred_occupied() {
let (occupied_listener, occupied) = occupy_exclusive();
let chosen = probe_free_port(Some(occupied)).expect("probe falls back to a free port");
assert_ne!(
chosen.port(),
occupied.port(),
"must not pick the occupied port"
);
assert!(chosen.ip().is_loopback(), "fallback stays on loopback");
assert!(
in_operator_range(chosen.port()),
"fallback must be an operator-range port (8000-8999/5000-5999), not ephemeral: {}",
chosen.port()
);
let rebind = bind_listener(chosen).expect("the chosen fallback port is free");
drop(rebind);
drop(occupied_listener);
}
#[tokio::test]
async fn probe_free_listener_threads_a_live_listener() {
let (occupied_listener, occupied) = occupy_exclusive();
let listener = probe_free_listener(Some(occupied)).expect("probe a live fallback listener");
let local = listener.local_addr().expect("local_addr");
assert_ne!(
local.port(),
occupied.port(),
"fell back off the occupied port"
);
assert!(
in_operator_range(local.port()),
"fallback must be an operator-range port, not ephemeral: {}",
local.port()
);
drop(listener);
drop(occupied_listener);
}
#[tokio::test]
async fn probe_free_port_none_preference_uses_operator_range() {
let chosen = probe_free_port(None).expect("probe with no preference");
assert!(chosen.ip().is_loopback());
assert!(
in_operator_range(chosen.port()),
"no-preference bind must be in the operator ranges, not ephemeral: {}",
chosen.port()
);
}
}