refactor(compute): simplify compiled driver boundary

Signed-off-by: Drew Newberry <anewberry@nvidia.com>

Author: drew

architecture/compute-runtimes.md

@@ -105,8 +105,10 @@ registry. Adding or removing a compiled driver therefore changes registration
 rather than the server's selection flow. Alternate gateway binaries can install
 their own `ComputeDriverFactory` registrations and hand the completed registry
 to `run_cli_with_compute_drivers`; factories receive merged driver config and
-finish through the same in-process runtime adapter. A configured UDS endpoint
-still takes precedence over a compiled registration with the same name.
+return either an in-process driver or a gateway-managed remote endpoint. The
+server constructs the common runtime adapter and snapshots `GetCapabilities`
+for either result. A configured UDS endpoint still takes precedence over a
+compiled registration with the same name.
 
 The `openshell-gateway` composition crate groups first-party registrations
 behind the `in-tree-compute-drivers` feature. `openshell-server` has no compute
@@ -402,13 +404,13 @@ image-pull Secrets in every operator-managed namespace.
 
 **Operator** uses pre-provisioned namespaces discovered through two optional
 sources: a K8s label selector (`operator_namespace_label`) and a drop-in
-allowlist file (`operator_namespace_file`). At least one must be configured.
-The `OperatorNamespaceAllowlist` (`Arc<RwLock<BTreeSet<String>>>`) is populated
-at runtime by background watchers and read by the namespace resolver. Sandbox
-creation fails closed if the workspace is not in the current allowlist. Platform
-teams manage namespace lifecycle externally. RBAC uses the same ClusterRole as
-managed mode but without namespace `create`/`delete` or ServiceAccount
-permissions.
+allowlist file (`operator_namespace_file`). Exactly one must be configured.
+The compute driver and the gateway's ServiceAccount authenticator independently
+watch that public config source; no in-process driver state crosses into the
+server. Sandbox creation and token bootstrap fail closed if the workspace is
+not in the current allowlist. Platform teams manage namespace lifecycle
+externally. RBAC uses the same ClusterRole as managed mode but without namespace
+`create`/`delete` or ServiceAccount permissions.
 
 ### Watching and Querying
 

crates/openshell-core/src/driver_utils.rs

@@ -352,9 +352,9 @@ pub fn read_upstream_proxy_credential_file(path: &str) -> Result<String, String>
 ///
 /// The resulting path is `$XDG_STATE_HOME/openshell/<driver_subdir>[/<namespace>]/<sandbox_id>/sandbox.jwt`.
 ///
-/// `driver_subdir` is driver-specific, e.g. `"docker-sandbox-tokens"` or
-/// `"podman-sandbox-tokens"`.  When `namespace` is `Some`, it is appended as
-/// an additional path component (with `/` and `\` replaced by `-`).
+/// `driver_subdir` is driver-specific. When `namespace` is `Some`, it is
+/// appended as an additional path component (with `/` and `\` replaced by
+/// `-`).
 ///
 /// # Errors
 /// Returns an error if the XDG state directory cannot be resolved.
@@ -405,7 +405,7 @@ pub fn sandbox_log_level(sandbox: &DriverSandbox, default_level: &str) -> String
 }
 
 // ---------------------------------------------------------------------------
-// Supervisor image helpers (shared by Docker and Podman drivers)
+// Supervisor image helpers shared by container-backed drivers
 // ---------------------------------------------------------------------------
 
 /// Return the tag portion of a supervisor image reference, or `None` if the
@@ -440,7 +440,7 @@ pub fn supervisor_image_should_refresh(image: &str) -> bool {
 }
 
 // ---------------------------------------------------------------------------
-// Supervisor binary extraction helpers (shared by Docker and Podman drivers)
+// Supervisor binary extraction helpers shared by container-backed drivers
 // ---------------------------------------------------------------------------
 
 #[cfg(feature = "driver-extraction")]
@@ -517,8 +517,7 @@ pub fn write_cache_binary_atomic(final_path: &Path, bytes: &[u8]) -> Result<(),
 /// Return the host-side cache path for an extracted supervisor binary.
 ///
 /// The path is `$XDG_DATA_HOME/openshell/<driver_subdir>/<sanitized-digest>/openshell-sandbox`.
-/// `driver_subdir` distinguishes caches across drivers (e.g. `"docker-supervisor"`,
-/// `"podman-supervisor"`).
+/// `driver_subdir` distinguishes caches across drivers.
 pub fn supervisor_cache_path(driver_subdir: &str, digest: &str) -> Result<PathBuf, String> {
     let base = crate::paths::xdg_data_dir()
         .map_err(|err| format!("failed to resolve XDG data dir: {err}"))?;

crates/openshell-core/src/error.rs

@@ -106,8 +106,8 @@ impl Error {
 
 /// Error type shared by all compute driver implementations.
 ///
-/// Both the Podman and Kubernetes drivers map their backend-specific
-/// errors into these variants before crossing crate boundaries.
+/// Drivers map backend-specific errors into these variants before crossing
+/// crate boundaries.
 #[derive(Debug, Error)]
 pub enum ComputeDriverError {
     /// The requested sandbox already exists.

crates/openshell-core/src/telemetry.rs

@@ -760,7 +760,7 @@ mod disabled_tests {
             1,
             false,
             SandboxTemplateSource::Default,
-            TelemetryComputeDriver::Docker,
+            TelemetryComputeDriver::from_raw("test-driver"),
         );
         emit_policy_decision(
             PolicyDecisionOperation::Approve,

crates/openshell-driver-docker/src/lib.rs

@@ -52,7 +52,7 @@ use openshell_core::proto::compute::v1::{
 use openshell_core::proto_struct::{
     deserialize_optional_non_empty_string_list, struct_to_json_value,
 };
-use openshell_core::{Config, Error, Result as CoreResult};
+use openshell_core::{Error, Result as CoreResult};
 use std::collections::{HashMap, HashSet};
 use std::net::{IpAddr, Ipv4Addr, SocketAddr};
 use std::path::{Path, PathBuf};
@@ -416,7 +416,11 @@ pub fn is_available() -> bool {
 }
 
 impl DockerComputeDriver {
-    pub async fn new(config: &Config, docker_config: &DockerComputeConfig) -> CoreResult<Self> {
+    pub async fn new(
+        gateway_bind_address: SocketAddr,
+        gateway_log_level: &str,
+        docker_config: &DockerComputeConfig,
+    ) -> CoreResult<Self> {
         let socket_path = docker_config
             .socket_path
             .clone()
@@ -446,7 +450,7 @@ impl DockerComputeDriver {
         let cdi_gpu_inventory = docker_cdi_gpu_inventory(&info);
         let allow_all_default_gpu = docker_info_reports_wsl2(&info);
         validate_sandbox_pids_limit(docker_config.sandbox_pids_limit)?;
-        let gateway_port = config.bind_address.port();
+        let gateway_port = gateway_bind_address.port();
         if gateway_port == 0 {
             return Err(Error::config(
                 "docker compute driver requires a fixed non-zero gateway bind port",
@@ -458,7 +462,7 @@ impl DockerComputeDriver {
         let gateway_route =
             docker_gateway_route(&info, bridge_gateway_ip, gateway_port, host_gateway_ip);
         let gateway_callback_bind_address =
-            docker_gateway_callback_bind_address(&gateway_route, config.bind_address);
+            docker_gateway_callback_bind_address(&gateway_route, gateway_bind_address);
         let mut docker_config = docker_config.clone();
         if docker_config.grpc_endpoint.trim().is_empty() {
             let scheme = if docker_guest_tls_configured(&docker_config) {
@@ -490,7 +494,7 @@ impl DockerComputeDriver {
                 gateway_callback_bind_address,
                 ssh_socket_path: docker_config.ssh_socket_path.clone(),
                 stop_timeout_secs: DEFAULT_STOP_TIMEOUT_SECS,
-                log_level: config.log_level.clone(),
+                log_level: gateway_log_level.to_string(),
                 supervisor_bin,
                 guest_tls,
                 daemon_version: version.version.unwrap_or_else(|| "unknown".to_string()),

crates/openshell-driver-docker/src/main.rs

@@ -6,8 +6,8 @@ use std::path::PathBuf;
 
 use clap::Parser;
 use miette::{IntoDiagnostic, Result};
+use openshell_core::VERSION;
 use openshell_core::proto::compute::v1::compute_driver_server::ComputeDriverServer;
-use openshell_core::{Config, VERSION};
 use openshell_driver_docker::{DockerComputeConfig, DockerComputeDriver};
 use tracing::info;
 use tracing_subscriber::EnvFilter;
@@ -46,8 +46,7 @@ async fn main() -> Result<()> {
 
     let config_source = std::fs::read_to_string(&args.config).into_diagnostic()?;
     let docker_config: DockerComputeConfig = toml::from_str(&config_source).into_diagnostic()?;
-    let gateway_config = Config::new(None).with_bind_address(args.gateway_bind);
-    let driver = DockerComputeDriver::new(&gateway_config, &docker_config)
+    let driver = DockerComputeDriver::new(args.gateway_bind, &args.log_level, &docker_config)
         .await
         .into_diagnostic()?;
 

crates/openshell-driver-podman/src/watcher.rs

@@ -121,15 +121,12 @@ fn deleted_event(sandbox_id: String) -> WatchSandboxesEvent {
 /// drops (daemon restart, socket error, or clean shutdown), the stream
 /// terminates with a final error item and stops producing events.
 ///
-/// Callers are responsible for reconnecting by calling [`start_watch`] again.
-/// The server's `ComputeRuntime::watch_loop` in `openshell-server` provides
-/// this behaviour with a 2-second backoff: when the stream terminates with an
-/// error, `watch_loop` sleeps and then calls `watch_sandboxes()` again, which
-/// ultimately calls `start_watch()` again and re-syncs state.
+/// Callers are responsible for reconnecting by calling [`start_watch`] again
+/// and re-synchronizing state.
 ///
 /// **Do not add reconnection logic inside this function.**  A local reconnect
-/// would race with `watch_loop`'s retry and produce duplicate initial-sync
-/// events that corrupt the server's sandbox index.
+/// would race with the consumer's retry and produce duplicate initial-sync
+/// events.
 pub async fn start_watch(
     client: PodmanClient,
     lifecycle_event_fences: LifecycleEventFences,

crates/openshell-gateway/src/lib.rs

@@ -110,7 +110,7 @@ impl openshell_server::ComputeDriverFactory for KubernetesFactory {
     async fn build(
         &self,
         context: openshell_server::ComputeDriverBuildContext<'_>,
-    ) -> openshell_core::Result<openshell_server::ComputeDriverBuildOutput> {
+    ) -> openshell_core::Result<openshell_server::ComputeDriverInstance> {
         let mut config: openshell_driver_kubernetes::KubernetesComputeConfig =
             context.driver_config()?;
         if let Ok(size) = std::env::var("OPENSHELL_K8S_WORKSPACE_DEFAULT_STORAGE_SIZE") {
@@ -119,27 +119,16 @@ impl openshell_server::ComputeDriverFactory for KubernetesFactory {
         if let Ok(storage_class) = std::env::var("OPENSHELL_K8S_WORKSPACE_STORAGE_CLASS") {
             config.workspace_storage_class = storage_class;
         }
-        if context
-            .gateway_config()
-            .gateway_jwt
-            .as_ref()
-            .is_some_and(|jwt| jwt.ttl_secs == 0)
-        {
-            tracing::warn!(
-                "Kubernetes gateway configured with non-expiring sandbox JWTs; set gateway_jwt.ttl_secs > 0 for shared deployments"
-            );
-        }
         let driver = openshell_driver_kubernetes::KubernetesComputeDriver::new(
             config,
             context.shutdown_receiver(),
         )
         .await
         .map_err(|error| openshell_core::Error::execution(error.to_string()))?;
-        let allowlist = driver.operator_allowlist().cloned();
         let driver = openshell_driver_kubernetes::ComputeDriverService::new(driver);
-        context
-            .finish_in_process_with_allowlist(std::sync::Arc::new(driver), allowlist)
-            .await
+        Ok(openshell_server::ComputeDriverInstance::InProcess(
+            std::sync::Arc::new(driver),
+        ))
     }
 }
 
@@ -153,19 +142,24 @@ impl openshell_server::ComputeDriverFactory for DockerFactory {
     async fn build(
         &self,
         context: openshell_server::ComputeDriverBuildContext<'_>,
-    ) -> openshell_core::Result<openshell_server::ComputeDriverBuildOutput> {
+    ) -> openshell_core::Result<openshell_server::ComputeDriverInstance> {
         let mut config: openshell_driver_docker::DockerComputeConfig = context.driver_config()?;
         apply_guest_tls(
             &mut config.guest_tls_ca,
             &mut config.guest_tls_cert,
             &mut config.guest_tls_key,
             context.guest_tls_paths(),
         );
-        let driver =
-            openshell_driver_docker::DockerComputeDriver::new(context.gateway_config(), &config)
-                .await
-                .map_err(|error| openshell_core::Error::execution(error.to_string()))?;
-        context.finish_in_process(std::sync::Arc::new(driver)).await
+        let driver = openshell_driver_docker::DockerComputeDriver::new(
+            context.gateway_bind_address(),
+            context.gateway_log_level(),
+            &config,
+        )
+        .await
+        .map_err(|error| openshell_core::Error::execution(error.to_string()))?;
+        Ok(openshell_server::ComputeDriverInstance::InProcess(
+            std::sync::Arc::new(driver),
+        ))
     }
 }
 
@@ -179,7 +173,7 @@ impl openshell_server::ComputeDriverFactory for PodmanFactory {
     async fn build(
         &self,
         context: openshell_server::ComputeDriverBuildContext<'_>,
-    ) -> openshell_core::Result<openshell_server::ComputeDriverBuildOutput> {
+    ) -> openshell_core::Result<openshell_server::ComputeDriverInstance> {
         let mut config: openshell_driver_podman::PodmanComputeConfig = context.driver_config()?;
         config.gateway_port = context.gateway_port();
         if let Ok(path) = std::env::var("OPENSHELL_PODMAN_SOCKET") {
@@ -201,7 +195,9 @@ impl openshell_server::ComputeDriverFactory for PodmanFactory {
             .await
             .map_err(|error| openshell_core::Error::execution(error.to_string()))?;
         let driver = openshell_driver_podman::ComputeDriverService::new(driver);
-        context.finish_in_process(std::sync::Arc::new(driver)).await
+        Ok(openshell_server::ComputeDriverInstance::InProcess(
+            std::sync::Arc::new(driver),
+        ))
     }
 }
 
@@ -215,7 +211,7 @@ impl openshell_server::ComputeDriverFactory for VmFactory {
     async fn build(
         &self,
         context: openshell_server::ComputeDriverBuildContext<'_>,
-    ) -> openshell_core::Result<openshell_server::ComputeDriverBuildOutput> {
+    ) -> openshell_core::Result<openshell_server::ComputeDriverInstance> {
         let mut config: vm::VmComputeConfig = context.driver_config()?;
         if config.state_dir.as_os_str().is_empty() {
             config.state_dir = vm::VmComputeConfig::default_state_dir();
@@ -236,8 +232,11 @@ impl openshell_server::ComputeDriverFactory for VmFactory {
             &mut config.guest_tls_key,
             context.guest_tls_paths(),
         );
-        let endpoint = vm::spawn(context.gateway_config(), &config, context.otlp_config()).await?;
-        context.finish_remote(endpoint).await
+        let endpoint =
+            vm::spawn(context.gateway_log_level(), &config, context.otlp_config()).await?;
+        Ok(openshell_server::ComputeDriverInstance::ManagedRemote(
+            endpoint,
+        ))
     }
 }
 

crates/openshell-gateway/src/vm.rs

@@ -35,7 +35,7 @@ use hyper_util::rt::TokioIo;
 use openshell_core::proto::compute::v1::{
     GetCapabilitiesRequest, compute_driver_client::ComputeDriverClient,
 };
-use openshell_core::{Config, Error, Result};
+use openshell_core::{Error, Result};
 #[cfg(unix)]
 use openshell_otel::TraceContextInterceptor;
 use openshell_server::AcquiredRemoteDriverEndpoint;
@@ -453,7 +453,7 @@ pub fn compute_driver_guest_tls_paths(
 /// kills the subprocess and removes the socket on drop.
 #[cfg(unix)]
 pub async fn spawn(
-    config: &Config,
+    gateway_log_level: &str,
     vm_config: &VmComputeConfig,
     otlp_config: Option<&OtlpConfig>,
 ) -> Result<AcquiredRemoteDriverEndpoint> {
@@ -477,7 +477,7 @@ pub async fn spawn(
     command
         .arg("--expected-peer-pid")
         .arg(std::process::id().to_string());
-    command.arg("--log-level").arg(&config.log_level);
+    command.arg("--log-level").arg(gateway_log_level);
     append_otlp_args(&mut command, otlp_config);
     command
         .arg("--openshell-endpoint")
@@ -527,7 +527,7 @@ fn append_otlp_args(command: &mut Command, otlp_config: Option<&OtlpConfig>) {
 
 #[cfg(not(unix))]
 pub async fn spawn(
-    _config: &Config,
+    _gateway_log_level: &str,
     _vm_config: &VmComputeConfig,
     _otlp_config: Option<&OtlpConfig>,
 ) -> Result<AcquiredRemoteDriverEndpoint> {