refactor: improve build ID generation with consistent timestamp format (#130)

refactor: improve build ID generation with consistent timestamp format

fix: lazy-start native opencode and simplify binary resolution

Author: NathanFlurry

docs/cli.mdx

@@ -71,15 +71,14 @@ sandbox-agent opencode [OPTIONS]
 | `-H, --host <HOST>` | `127.0.0.1` | Host to bind to |
 | `-p, --port <PORT>` | `2468` | Port to bind to |
 | `--session-title <TITLE>` | - | Title for the OpenCode session |
-| `--opencode-bin <PATH>` | - | Override `opencode` binary path |
 
 ```bash
 sandbox-agent opencode --token "$TOKEN"
 ```
 
 The daemon logs to a per-host log file under the sandbox-agent data directory (for example, `~/.local/share/sandbox-agent/daemon/daemon-127-0-0-1-2468.log`).
 
-Requires the `opencode` binary to be installed (or set `OPENCODE_BIN` / `--opencode-bin`). If it is not found on `PATH`, sandbox-agent installs it automatically.
+Existing installs are reused and missing binaries are installed automatically.
 
 ---
 

server/packages/agent-management/src/agents.rs

@@ -168,9 +168,7 @@ impl AgentManager {
         if agent == AgentId::Mock {
             return true;
         }
-        self.binary_path(agent).exists()
-            || find_in_path(agent.binary_name()).is_some()
-            || default_install_dir().join(agent.binary_name()).exists()
+        self.binary_path(agent).exists() || find_in_path(agent.binary_name()).is_some()
     }
 
     pub fn binary_path(&self, agent: AgentId) -> PathBuf {
@@ -641,10 +639,6 @@ impl AgentManager {
         if let Some(path) = find_in_path(agent.binary_name()) {
             return Ok(path);
         }
-        let fallback = default_install_dir().join(agent.binary_name());
-        if fallback.exists() {
-            return Ok(fallback);
-        }
         Err(AgentError::BinaryNotFound { agent })
     }
 }
@@ -1193,12 +1187,6 @@ fn find_in_path(binary_name: &str) -> Option<PathBuf> {
     None
 }
 
-fn default_install_dir() -> PathBuf {
-    dirs::data_dir()
-        .map(|dir| dir.join("sandbox-agent").join("bin"))
-        .unwrap_or_else(|| PathBuf::from(".").join(".sandbox-agent").join("bin"))
-}
-
 fn download_bytes(url: &Url) -> Result<Vec<u8>, AgentError> {
     let client = Client::builder().build()?;
     let mut response = client.get(url.clone()).send()?;

server/packages/sandbox-agent/build.rs

@@ -99,26 +99,23 @@ fn generate_version(out_dir: &Path) {
 fn generate_build_id(out_dir: &Path) {
     use std::process::Command;
 
-    let build_id = Command::new("git")
+    let source_id = Command::new("git")
         .args(["rev-parse", "--short", "HEAD"])
         .output()
         .ok()
         .filter(|o| o.status.success())
         .and_then(|o| String::from_utf8(o.stdout).ok())
         .map(|s| s.trim().to_string())
-        .unwrap_or_else(|| {
-            // Fallback: use the package version + compile-time timestamp
-            let version = env::var("CARGO_PKG_VERSION").unwrap_or_default();
-            let timestamp = std::time::SystemTime::now()
-                .duration_since(std::time::UNIX_EPOCH)
-                .map(|d| d.as_secs().to_string())
-                .unwrap_or_default();
-            format!("{version}-{timestamp}")
-        });
+        .unwrap_or_else(|| env::var("CARGO_PKG_VERSION").unwrap_or_default());
+    let timestamp = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map(|d| d.as_nanos().to_string())
+        .unwrap_or_else(|_| "0".to_string());
+    let build_id = format!("{source_id}-{timestamp}");
 
     let out_file = out_dir.join("build_id.rs");
     let contents = format!(
-        "/// Unique identifier for this build (git short hash or version-timestamp fallback).\n\
+        "/// Unique identifier for this build (source id + build timestamp).\n\
          pub const BUILD_ID: &str = \"{}\";\n",
         build_id
     );

server/packages/sandbox-agent/src/cli.rs

@@ -126,9 +126,6 @@ pub struct OpencodeArgs {
 
     #[arg(long)]
     session_title: Option<String>,
-
-    #[arg(long)]
-    opencode_bin: Option<PathBuf>,
 }
 
 impl Default for OpencodeArgs {
@@ -137,7 +134,6 @@ impl Default for OpencodeArgs {
             host: DEFAULT_HOST.to_string(),
             port: DEFAULT_PORT,
             session_title: None,
-            opencode_bin: None,
         }
     }
 }
@@ -606,7 +602,7 @@ fn run_opencode(cli: &CliConfig, args: &OpencodeArgs) -> Result<(), CliError> {
     write_stdout_line(&format!("OpenCode session: {session_id}"))?;
 
     let attach_url = format!("{base_url}/opencode");
-    let opencode_bin = resolve_opencode_bin(args.opencode_bin.as_ref())?;
+    let opencode_bin = resolve_opencode_bin()?;
     let mut opencode_cmd = ProcessCommand::new(opencode_bin);
     opencode_cmd
         .arg("attach")
@@ -844,50 +840,19 @@ fn create_opencode_session(
     Ok(session_id.to_string())
 }
 
-fn resolve_opencode_bin(explicit: Option<&PathBuf>) -> Result<PathBuf, CliError> {
-    if let Some(path) = explicit {
-        return Ok(path.clone());
-    }
-    if let Ok(path) = std::env::var("OPENCODE_BIN") {
-        return Ok(PathBuf::from(path));
-    }
-    if let Some(path) = find_in_path("opencode") {
-        write_stderr_line(&format!(
-            "using opencode binary from PATH: {}",
-            path.display()
-        ))?;
-        return Ok(path);
-    }
-
+fn resolve_opencode_bin() -> Result<PathBuf, CliError> {
     let manager = AgentManager::new(default_install_dir())
         .map_err(|err| CliError::Server(err.to_string()))?;
-    match manager.resolve_binary(AgentId::Opencode) {
-        Ok(path) => Ok(path),
-        Err(_) => {
-            write_stderr_line("opencode not found; installing...")?;
-            let result = manager
-                .install(
-                    AgentId::Opencode,
-                    InstallOptions {
-                        reinstall: false,
-                        version: None,
-                    },
-                )
-                .map_err(|err| CliError::Server(err.to_string()))?;
-            Ok(result.path)
-        }
-    }
-}
-
-fn find_in_path(binary_name: &str) -> Option<PathBuf> {
-    let path_var = std::env::var_os("PATH")?;
-    for path in std::env::split_paths(&path_var) {
-        let candidate = path.join(binary_name);
-        if candidate.exists() {
-            return Some(candidate);
-        }
+    match manager.install(
+        AgentId::Opencode,
+        InstallOptions {
+            reinstall: false,
+            version: None,
+        },
+    ) {
+        Ok(result) => Ok(result.path),
+        Err(err) => Err(CliError::Server(err.to_string())),
     }
-    None
 }
 
 fn run_credentials(command: &CredentialsCommand) -> Result<(), CliError> {

server/packages/sandbox-agent/src/daemon.rs

@@ -10,7 +10,6 @@ use crate::cli::{CliConfig, CliError};
 mod build_id {
     include!(concat!(env!("OUT_DIR"), "/build_id.rs"));
 }
-
 pub use build_id::BUILD_ID;
 
 const DAEMON_HEALTH_TIMEOUT: Duration = Duration::from_secs(30);
@@ -446,7 +445,10 @@ pub fn ensure_running(
         // Check build version
         if !is_version_current(host, port) {
             let old = read_daemon_version(host, port).unwrap_or_else(|| "unknown".to_string());
-            eprintln!("daemon outdated (build {old} -> {BUILD_ID}), restarting...");
+            eprintln!(
+                "daemon outdated (build {old} -> {}), restarting...",
+                BUILD_ID
+            );
             stop(host, port)?;
             return start(cli, host, port, token);
         }

server/packages/sandbox-agent/src/opencode_compat.rs

@@ -23,7 +23,7 @@ use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
 use tokio::sync::{broadcast, Mutex};
 use tokio::time::interval;
-use tracing::warn;
+use tracing::{info, warn};
 use utoipa::{IntoParams, OpenApi, ToSchema};
 
 use crate::router::{
@@ -656,21 +656,38 @@ fn default_agent_mode() -> &'static str {
 }
 
 async fn opencode_model_cache(state: &OpenCodeAppState) -> OpenCodeModelCache {
-    {
-        let cache = state.opencode.model_cache.lock().await;
-        if let Some(cache) = cache.as_ref() {
-            return cache.clone();
-        }
+    // Keep this lock for the full build to enforce singleflight behavior.
+    // Concurrent requests wait for the same in-flight build instead of
+    // spawning duplicate provider/model fetches.
+    let mut slot = state.opencode.model_cache.lock().await;
+    if let Some(cache) = slot.as_ref() {
+        info!(
+            entries = cache.entries.len(),
+            groups = cache.group_names.len(),
+            connected = cache.connected.len(),
+            "opencode model cache hit"
+        );
+        return cache.clone();
     }
 
+    let started = std::time::Instant::now();
+    info!("opencode model cache miss; building cache");
     let cache = build_opencode_model_cache(state).await;
-    let mut slot = state.opencode.model_cache.lock().await;
+    info!(
+        elapsed_ms = started.elapsed().as_millis() as u64,
+        entries = cache.entries.len(),
+        groups = cache.group_names.len(),
+        connected = cache.connected.len(),
+        "opencode model cache built"
+    );
     *slot = Some(cache.clone());
     cache
 }
 
 async fn build_opencode_model_cache(state: &OpenCodeAppState) -> OpenCodeModelCache {
+    let started = std::time::Instant::now();
     // Check credentials upfront
+    let creds_started = std::time::Instant::now();
     let credentials = match tokio::task::spawn_blocking(|| {
         extract_all_credentials(&CredentialExtractionOptions::new())
     })
@@ -684,6 +701,10 @@ async fn build_opencode_model_cache(state: &OpenCodeAppState) -> OpenCodeModelCa
     };
     let has_anthropic = credentials.anthropic.is_some();
     let has_openai = credentials.openai.is_some();
+    info!(
+        elapsed_ms = creds_started.elapsed().as_millis() as u64,
+        has_anthropic, has_openai, "opencode model cache credential scan complete"
+    );
 
     let mut entries = Vec::new();
     let mut model_lookup = HashMap::new();
@@ -693,11 +714,38 @@ async fn build_opencode_model_cache(state: &OpenCodeAppState) -> OpenCodeModelCa
     let mut group_names: HashMap<String, String> = HashMap::new();
     let mut default_model: Option<String> = None;
 
-    for agent in available_agent_ids() {
-        let response = match state.inner.session_manager().agent_models(agent).await {
+    let agents = available_agent_ids();
+    let manager = state.inner.session_manager();
+    let fetches = agents.iter().copied().map(|agent| {
+        let manager = manager.clone();
+        async move {
+            let agent_started = std::time::Instant::now();
+            let response = manager.agent_models(agent).await;
+            (agent, agent_started.elapsed(), response)
+        }
+    });
+    let fetch_results = futures::future::join_all(fetches).await;
+
+    for (agent, elapsed, response) in fetch_results {
+        let response = match response {
             Ok(response) => response,
-            Err(_) => continue,
+            Err(err) => {
+                warn!(
+                    agent = agent.as_str(),
+                    elapsed_ms = elapsed.as_millis() as u64,
+                    ?err,
+                    "opencode model cache failed fetching agent models"
+                );
+                continue;
+            }
         };
+        info!(
+            agent = agent.as_str(),
+            elapsed_ms = elapsed.as_millis() as u64,
+            model_count = response.models.len(),
+            has_default = response.default_model.is_some(),
+            "opencode model cache fetched agent models"
+        );
 
         let first_model_id = response.models.first().map(|model| model.id.clone());
         for model in response.models {
@@ -805,7 +853,7 @@ async fn build_opencode_model_cache(state: &OpenCodeAppState) -> OpenCodeModelCa
         }
     }
 
-    OpenCodeModelCache {
+    let cache = OpenCodeModelCache {
         entries,
         model_lookup,
         group_defaults,
@@ -814,7 +862,17 @@ async fn build_opencode_model_cache(state: &OpenCodeAppState) -> OpenCodeModelCa
         default_group,
         default_model,
         connected,
-    }
+    };
+    info!(
+        elapsed_ms = started.elapsed().as_millis() as u64,
+        entries = cache.entries.len(),
+        groups = cache.group_names.len(),
+        connected = cache.connected.len(),
+        default_group = cache.default_group.as_str(),
+        default_model = cache.default_model.as_str(),
+        "opencode model cache build complete"
+    );
+    cache
 }
 
 fn resolve_agent_from_model(
@@ -1123,8 +1181,16 @@ async fn proxy_native_opencode(
     headers: &HeaderMap,
     body: Option<Value>,
 ) -> Option<Response> {
-    let Some(base_url) = state.opencode.proxy_base_url() else {
-        return None;
+    let base_url = if let Some(base_url) = state.opencode.proxy_base_url() {
+        base_url.to_string()
+    } else {
+        match state.inner.ensure_opencode_server().await {
+            Ok(base_url) => base_url,
+            Err(err) => {
+                warn!(path, ?err, "failed to lazily start native opencode server");
+                return None;
+            }
+        }
     };
 
     let mut request = state