fix(upgrade): preserve pre.4 supervisor compatibility

Signed-off-by: Evan Lezar <elezar@nvidia.com>

Author: elezar

crates/openshell-policy/src/lib.rs

@@ -472,6 +472,7 @@ fn yaml_mcp_method(
     method.to_string()
 }
 
+#[allow(deprecated)]
 fn to_proto(raw: PolicyFile) -> Result<SandboxPolicy> {
     for (policy_name, rule) in &raw.network_policies {
         for (endpoint_index, endpoint) in rule.endpoints.iter().enumerate() {
@@ -518,6 +519,9 @@ fn to_proto(raw: PolicyFile) -> Result<SandboxPolicy> {
                         };
                         NetworkEndpoint {
                             host: e.host,
+                            legacy_tls: String::new(),
+                            legacy_enforcement: String::new(),
+                            legacy_access: String::new(),
                             path: e.path,
                             port: normalized_ports.first().copied().unwrap_or(0),
                             ports: normalized_ports,

crates/openshell-providers/src/profiles.rs

@@ -1630,9 +1630,13 @@ fn discovery_to_proto(discovery: &DiscoveryProfile) -> ProviderProfileDiscovery
     }
 }
 
+#[allow(deprecated)]
 fn endpoint_to_proto(endpoint: &EndpointProfile) -> NetworkEndpoint {
     NetworkEndpoint {
         host: endpoint.host.clone(),
+        legacy_tls: String::new(),
+        legacy_enforcement: String::new(),
+        legacy_access: String::new(),
         port: endpoint.port,
         protocol: endpoint.protocol.clone(),
         tls: network_tls_mode_from_str(&endpoint.tls).map_or(-1, |value| value as i32),

crates/openshell-server/src/grpc/policy.rs

@@ -2576,6 +2576,10 @@ async fn handle_get_sandbox_config_inner(
 ) -> Result<Response<GetSandboxConfigResponse>, Status> {
     let principal = super::extract_principal(&request)?;
     let req = request.into_inner();
+    let legacy_supervisor = matches!(
+        &principal,
+        Principal::Sandbox(sandbox) if req.workspace_scope.is_none() && req.name == sandbox.sandbox_id
+    );
     let workspace = match &principal {
         Principal::Sandbox(_) if req.workspace_scope.is_none() => "",
         _ => crate::auth::workspace_authz::selected_workspace_name(req.workspace_scope.as_ref())?,
@@ -2588,7 +2592,35 @@ async fn handle_get_sandbox_config_inner(
         MinWorkspaceRole::User,
     )
     .await?;
-    Ok(Response::new(load_sandbox_config(state, &sandbox).await?))
+    let mut config = load_sandbox_config(state, &sandbox).await?;
+    if legacy_supervisor && let Some(policy) = config.policy.as_mut() {
+        populate_legacy_endpoint_modes(policy)?;
+    }
+    Ok(Response::new(config))
+}
+
+#[allow(deprecated)]
+fn populate_legacy_endpoint_modes(policy: &mut ProtoSandboxPolicy) -> Result<(), Status> {
+    for rule in policy.network_policies.values_mut() {
+        for endpoint in &mut rule.endpoints {
+            endpoint.legacy_tls = openshell_policy::network_tls_mode_to_str(endpoint.tls)
+                .ok_or_else(|| Status::internal("effective policy contains an unknown TLS mode"))?
+                .to_string();
+            endpoint.legacy_enforcement =
+                openshell_policy::network_enforcement_mode_to_str(endpoint.enforcement)
+                    .ok_or_else(|| {
+                        Status::internal("effective policy contains an unknown enforcement mode")
+                    })?
+                    .to_string();
+            endpoint.legacy_access =
+                openshell_policy::network_access_preset_to_str(endpoint.access)
+                    .ok_or_else(|| {
+                        Status::internal("effective policy contains an unknown access preset")
+                    })?
+                    .to_string();
+        }
+    }
+    Ok(())
 }
 
 /// Resolve the same effective configuration for authenticated RPCs and trusted
@@ -7503,6 +7535,45 @@ mod tests {
     use std::sync::atomic::{AtomicUsize, Ordering};
     use tonic::Code;
 
+    #[derive(Clone, PartialEq, prost::Message)]
+    struct LegacyNetworkEndpoint {
+        #[prost(string, tag = "4")]
+        tls: String,
+        #[prost(string, tag = "5")]
+        enforcement: String,
+        #[prost(string, tag = "6")]
+        access: String,
+    }
+
+    #[test]
+    fn legacy_endpoint_modes_remain_decodable_by_pre4_supervisors() {
+        use openshell_core::proto::{NetworkAccessPreset, NetworkEnforcementMode, NetworkTlsMode};
+
+        let mut policy = ProtoSandboxPolicy {
+            network_policies: HashMap::from([(
+                "api".to_string(),
+                NetworkPolicyRule {
+                    endpoints: vec![NetworkEndpoint {
+                        tls: NetworkTlsMode::Skip.into(),
+                        enforcement: NetworkEnforcementMode::Enforce.into(),
+                        access: NetworkAccessPreset::ReadWrite.into(),
+                        ..Default::default()
+                    }],
+                    ..Default::default()
+                },
+            )]),
+            ..Default::default()
+        };
+
+        populate_legacy_endpoint_modes(&mut policy).unwrap();
+        let encoded = policy.network_policies["api"].endpoints[0].encode_to_vec();
+        let legacy = LegacyNetworkEndpoint::decode(encoded.as_slice()).unwrap();
+
+        assert_eq!(legacy.tls, "skip");
+        assert_eq!(legacy.enforcement, "enforce");
+        assert_eq!(legacy.access, "read-write");
+    }
+
     /// Wrap a request with a user `Principal` so handler scope guards treat
     /// the test caller as a CLI user. Most handler tests exercise
     /// user-facing behavior and should not trip sandbox equality checks.

crates/openshell-server/src/grpc/sandbox.rs

@@ -203,7 +203,11 @@ pub(super) async fn resolve_and_authorize_sandbox_name(
         .map_err(|e| Status::internal(format!("fetch sandbox failed: {e}")))?
         .filter(|sandbox| {
             sandbox.metadata.as_ref().is_some_and(|metadata| {
-                metadata.name == sandbox_name
+                // Supervisors released before sandbox names became the
+                // canonical RPC reference send their authenticated sandbox
+                // UUID in the same protobuf field. The principal is already
+                // bound to that UUID, so accepting it cannot widen scope.
+                (metadata.name == sandbox_name || sandbox_principal.sandbox_id == sandbox_name)
                     && (workspace.is_empty() || workspace == sandbox.object_workspace())
             })
         });
@@ -3920,6 +3924,7 @@ async fn run_exec_with_russh(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::auth::principal::{Principal, SandboxIdentitySource, SandboxPrincipal};
     use crate::compute::NoopTestDriver;
 
     #[test]
@@ -4391,6 +4396,33 @@ mod tests {
         sandbox
     }
 
+    #[tokio::test]
+    async fn sandbox_principal_accepts_legacy_id_reference_for_its_own_sandbox() {
+        let state = test_server_state().await;
+        let sandbox = test_sandbox("legacy-reference", Vec::new());
+        let sandbox_id = sandbox.object_id().to_string();
+        state.store.put_message(&sandbox).await.unwrap();
+        let principal = Principal::Sandbox(SandboxPrincipal {
+            sandbox_id: sandbox_id.clone(),
+            source: SandboxIdentitySource::BootstrapJwt {
+                issuer: "openshell-gateway:test".to_string(),
+            },
+            trust_domain: Some("openshell".to_string()),
+        });
+
+        let resolved = resolve_and_authorize_sandbox_name(
+            &state,
+            &principal,
+            &sandbox_id,
+            "",
+            MinWorkspaceRole::User,
+        )
+        .await
+        .unwrap();
+
+        assert_eq!(resolved.object_id(), sandbox_id);
+    }
+
     fn test_workload_template(name: &str) -> SandboxWorkloadTemplate {
         SandboxWorkloadTemplate {
             metadata: Some(ObjectMeta {

crates/openshell-server/src/persistence/legacy_time_wire.rs

@@ -332,13 +332,13 @@ fn conversion(message: &str, field: u32) -> Option<Conversion> {
             Some(D { new_tag: 116 })
         }
         ("openshell.sandbox.v1.MiddlewareBinding", 4) => Some(DS { new_tag: 104 }),
-        ("openshell.sandbox.v1.NetworkEndpoint", 4) => Some(E { tag: 4, kind: Tls }),
+        ("openshell.sandbox.v1.NetworkEndpoint", 4) => Some(E { tag: 27, kind: Tls }),
         ("openshell.sandbox.v1.NetworkEndpoint", 5) => Some(E {
-            tag: 5,
+            tag: 28,
             kind: Enforcement,
         }),
         ("openshell.sandbox.v1.NetworkEndpoint", 6) => Some(E {
-            tag: 6,
+            tag: 29,
             kind: Access,
         }),
         _ => None,

crates/openshell-server/src/storage_proto.rs

@@ -128,10 +128,12 @@ mod tests {
     // the additive file map while retaining the rest of the response.
     // Service authorization also extends both schemas additively. Legacy
     // payloads retain the safe Strip default.
+    // NetworkEndpoint retains the pre.4 string fields while current enum fields
+    // use new tags, changing both schema fingerprints without changing ownership.
     const PUBLIC_RPC_SCHEMA_SHA256: &str =
-        "2e156c6ad3c8eb51bcd30dc13b173fe339b38207a1b1f98f7be2e0cad8e3bd45";
+        "013858ac39a29d738626115f9bdc70f30c5bcf21072dd42cddb2e77a14d721d1";
     const DURABLE_SCHEMA_SHA256: &str =
-        "38165d9d76f49fcfe98a12f241e032838a2376c1d1a87ea2796fd33b9b1a3541";
+        "6f53e9371c30c7d8586f588363f618aaccbe7bba36e8c27f2a5f829f7535bd55";
     const PUBLIC_DURABLE_OVERLAP_SHA256: &str =
         "761dea31a521b0650840fe2a823ad6e36a265ed323ba4506889781d630df0ee3";
     // A persisted Sandbox without endpoint status retains its lifecycle fields;

crates/openshell-supervisor-network/src/policy_local.rs

@@ -1120,6 +1120,7 @@ fn network_rule_from_json(
     })
 }
 
+#[allow(deprecated)]
 fn network_endpoint_from_json(
     endpoint: NetworkEndpointJson,
 ) -> std::result::Result<NetworkEndpoint, String> {
@@ -1192,6 +1193,9 @@ fn network_endpoint_from_json(
 
     Ok(NetworkEndpoint {
         host: endpoint.host,
+        legacy_tls: String::new(),
+        legacy_enforcement: String::new(),
+        legacy_access: String::new(),
         port,
         protocol: endpoint.protocol,
         tls: openshell_policy::network_tls_mode_from_str(&endpoint.tls)

proto/sandbox.proto

@@ -148,13 +148,11 @@ message NetworkEndpoint {
   // Endpoint protocol. "tcp" and "" select L4-only handling; "rest",
   // "websocket", "graphql", "sql", "json-rpc", and "mcp" select L7 inspection.
   string protocol = 3;
-  // TLS handling. Unspecified enables automatic detection and termination.
-  NetworkTlsMode tls = 4;
-  // Enforcement mode. Unspecified preserves the audit default.
-  NetworkEnforcementMode enforcement = 5;
-  // Access preset shorthand. Unspecified means no preset.
-  // Mutually exclusive with rules.
-  NetworkAccessPreset access = 6;
+  // Deprecated string representation retained for supervisors released before
+  // endpoint security modes became typed enums.
+  string legacy_tls = 4 [deprecated = true];
+  string legacy_enforcement = 5 [deprecated = true];
+  string legacy_access = 6 [deprecated = true];
   // Explicit L7 rules (mutually exclusive with access).
   repeated L7Rule rules = 7;
   // Allowed resolved IP addresses or CIDR ranges for this endpoint.
@@ -230,6 +228,13 @@ message NetworkEndpoint {
   // Internal gateway-derived marker indicating that this endpoint belongs to
   // an attached credentialed provider. User-authored values are ignored.
   bool provider_credentialed = 26;
+  // TLS handling. Unspecified enables automatic detection and termination.
+  NetworkTlsMode tls = 27;
+  // Enforcement mode. Unspecified preserves the audit default.
+  NetworkEnforcementMode enforcement = 28;
+  // Access preset shorthand. Unspecified means no preset.
+  // Mutually exclusive with rules.
+  NetworkAccessPreset access = 29;
 }
 
 // MCP options are grouped so MCP-specific policy can grow without adding more