use std::fs::{self, OpenOptions};
use std::net::TcpListener;
use std::path::{Path, PathBuf};
use std::process::{Child, Command, ExitStatus, Stdio};
use std::sync::{Arc, Mutex as StdMutex};
use std::time::Duration;
use reqwest::Client;
use sandbox_agent_agent_management::agents::{AgentId, AgentManager};
use tokio::sync::Mutex;
use tokio::time::sleep;
use tracing::warn;
const HEALTH_ENDPOINTS: [&str; 4] = ["health", "healthz", "app/agents", "agents"];
const HEALTH_ATTEMPTS: usize = 20;
const HEALTH_DELAY_MS: u64 = 150;
const MONITOR_DELAY_MS: u64 = 500;
#[derive(Debug, Clone)]
pub struct OpenCodeServerManagerConfig {
pub log_dir: PathBuf,
pub auto_restart: bool,
}
impl Default for OpenCodeServerManagerConfig {
fn default() -> Self {
Self {
log_dir: default_log_dir(),
auto_restart: true,
}
}
}
#[derive(Debug, Clone)]
pub struct OpenCodeServerManager {
inner: Arc<Inner>,
}
#[derive(Debug)]
struct Inner {
agent_manager: Arc<AgentManager>,
http_client: Client,
config: OpenCodeServerManagerConfig,
ensure_lock: Mutex<()>,
state: Mutex<ManagerState>,
}
#[derive(Debug, Default)]
struct ManagerState {
server: Option<RunningServer>,
restart_count: u64,
shutdown_requested: bool,
last_error: Option<String>,
}
#[derive(Debug, Clone)]
struct RunningServer {
base_url: String,
child: Arc<StdMutex<Option<Child>>>,
instance_id: u64,
}
impl OpenCodeServerManager {
pub fn new(agent_manager: Arc<AgentManager>, config: OpenCodeServerManagerConfig) -> Self {
Self {
inner: Arc::new(Inner {
agent_manager,
http_client: Client::new(),
config,
ensure_lock: Mutex::new(()),
state: Mutex::new(ManagerState::default()),
}),
}
}
pub async fn ensure_server(&self) -> Result<String, String> {
let _guard = self.inner.ensure_lock.lock().await;
if let Some(base_url) = self.running_base_url().await {
return Ok(base_url);
}
let (base_url, child) = self.spawn_http_server().await?;
if let Err(err) = self.wait_for_http_server(&base_url).await {
kill_child(&child);
let mut state = self.inner.state.lock().await;
state.last_error = Some(err.clone());
return Err(err);
}
let instance_id = {
let mut state = self.inner.state.lock().await;
state.shutdown_requested = false;
state.restart_count += 1;
let instance_id = state.restart_count;
state.server = Some(RunningServer {
base_url: base_url.clone(),
child: child.clone(),
instance_id,
});
state.last_error = None;
instance_id
};
self.spawn_monitor_task(instance_id, child);
Ok(base_url)
}
pub async fn shutdown(&self) {
let _guard = self.inner.ensure_lock.lock().await;
let child = {
let mut state = self.inner.state.lock().await;
state.shutdown_requested = true;
state.server.take().map(|server| server.child)
};
if let Some(child) = child {
kill_child(&child);
}
}
async fn running_base_url(&self) -> Option<String> {
let running = {
let state = self.inner.state.lock().await;
state.server.clone()
}?;
if child_is_alive(&running.child) {
return Some(running.base_url);
}
let mut state = self.inner.state.lock().await;
if state
.server
.as_ref()
.map(|server| server.instance_id == running.instance_id)
.unwrap_or(false)
{
state.server = None;
}
None
}
async fn wait_for_http_server(&self, base_url: &str) -> Result<(), String> {
for _ in 0..HEALTH_ATTEMPTS {
for endpoint in HEALTH_ENDPOINTS {
let url = format!("{base_url}/{endpoint}");
match self.inner.http_client.get(&url).send().await {
Ok(response) if response.status().is_success() => return Ok(()),
Ok(_) | Err(_) => {}
}
}
sleep(Duration::from_millis(HEALTH_DELAY_MS)).await;
}
Err("OpenCode server health check failed".to_string())
}
async fn spawn_http_server(&self) -> Result<(String, Arc<StdMutex<Option<Child>>>), String> {
let agent_manager = self.inner.agent_manager.clone();
let log_dir = self.inner.config.log_dir.clone();
let (base_url, child) = tokio::task::spawn_blocking(move || {
let path = agent_manager
.resolve_binary(AgentId::Opencode)
.map_err(|err| err.to_string())?;
let port = find_available_port()?;
let mut command = Command::new(path);
let stderr = open_opencode_log(&log_dir).unwrap_or_else(|_| Stdio::null());
command
.arg("serve")
.arg("--port")
.arg(port.to_string())
.stdout(Stdio::null())
.stderr(stderr);
let child = command.spawn().map_err(|err| err.to_string())?;
Ok::<(String, Child), String>((format!("http://127.0.0.1:{port}"), child))
})
.await
.map_err(|err| err.to_string())??;
Ok((base_url, Arc::new(StdMutex::new(Some(child)))))
}
fn spawn_monitor_task(&self, instance_id: u64, child: Arc<StdMutex<Option<Child>>>) {
let manager = self.clone();
tokio::spawn(async move {
loop {
let status = {
let mut guard = match child.lock() {
Ok(guard) => guard,
Err(_) => return,
};
match guard.as_mut() {
Some(child) => match child.try_wait() {
Ok(status) => status,
Err(_) => None,
},
None => return,
}
};
if let Some(status) = status {
manager.handle_process_exit(instance_id, status).await;
return;
}
sleep(Duration::from_millis(MONITOR_DELAY_MS)).await;
}
});
}
async fn handle_process_exit(&self, instance_id: u64, status: ExitStatus) {
let (should_restart, error_message) = {
let mut state = self.inner.state.lock().await;
let Some(server) = state.server.as_ref() else {
return;
};
if server.instance_id != instance_id {
return;
}
let message = format!("OpenCode server exited with status {:?}", status);
let shutdown_requested = state.shutdown_requested;
if !shutdown_requested {
state.last_error = Some(message.clone());
}
state.server = None;
(
!shutdown_requested && self.inner.config.auto_restart,
message,
)
};
if !should_restart {
return;
}
let manager = self.clone();
tokio::spawn(async move {
sleep(Duration::from_millis(MONITOR_DELAY_MS)).await;
if let Err(err) = manager.ensure_server().await {
warn!(
error = ?err,
prior_exit = %error_message,
"failed to restart OpenCode compat sidecar"
);
}
});
}
}
fn default_log_dir() -> PathBuf {
let mut base = dirs::data_local_dir().unwrap_or_else(|| std::env::temp_dir());
base.push("sandbox-agent");
base.push("agent-logs");
base
}
fn open_opencode_log(log_dir: &Path) -> Result<Stdio, String> {
let directory = log_dir.join("opencode");
fs::create_dir_all(&directory).map_err(|err| err.to_string())?;
let path = directory.join("opencode-compat.log");
let file = OpenOptions::new()
.create(true)
.append(true)
.open(path)
.map_err(|err| err.to_string())?;
Ok(file.into())
}
fn find_available_port() -> Result<u16, String> {
let listener = TcpListener::bind("127.0.0.1:0").map_err(|err| err.to_string())?;
let port = listener.local_addr().map_err(|err| err.to_string())?.port();
drop(listener);
Ok(port)
}
fn child_is_alive(child: &Arc<StdMutex<Option<Child>>>) -> bool {
let mut guard = match child.lock() {
Ok(guard) => guard,
Err(_) => return false,
};
let Some(child) = guard.as_mut() else {
return false;
};
match child.try_wait() {
Ok(Some(_)) => {
*guard = None;
false
}
Ok(None) => true,
Err(_) => false,
}
}
fn kill_child(child: &Arc<StdMutex<Option<Child>>>) {
if let Ok(mut guard) = child.lock() {
if let Some(child) = guard.as_mut() {
let _ = child.kill();
}
*guard = None;
}
}