From c82320f532b5e6f36a446608d7671c4bd49be8d0 Mon Sep 17 00:00:00 2001 From: Gordon Sim Date: Thu, 13 Aug 2026 21:20:40 +0100 Subject: [PATCH] feat(sandbox): add delegated identity for token exchange Signed-off-by: Gordon Sim --- architecture/sandbox.md | 22 +- crates/openshell-cli/src/main.rs | 252 + crates/openshell-cli/src/run.rs | 738 +- .../tests/ensure_providers_integration.rs | 58 + .../openshell-cli/tests/mtls_integration.rs | 58 + .../tests/provider_commands_integration.rs | 58 + .../sandbox_create_lifecycle_integration.rs | 58 + .../sandbox_name_fallback_integration.rs | 58 + crates/openshell-core/src/config.rs | 14 + crates/openshell-core/src/metadata.rs | 87 +- crates/openshell-core/src/oauth.rs | 94 + .../src/proto_json.rs | 1 + .../src/runtime.rs | 1 + crates/openshell-providers/src/profiles.rs | 60 +- crates/openshell-sdk/src/client.rs | 1 + crates/openshell-sdk/tests/client_mock.rs | 49 + crates/openshell-server/src/auth/oidc.rs | 32 +- crates/openshell-server/src/cli.rs | 7 + crates/openshell-server/src/compute/mod.rs | 13 +- crates/openshell-server/src/config_file.rs | 2 + .../src/delegated_identity.rs | 1639 ++++ crates/openshell-server/src/grpc/mod.rs | 82 +- crates/openshell-server/src/grpc/policy.rs | 16 + crates/openshell-server/src/grpc/provider.rs | 63 +- crates/openshell-server/src/grpc/sandbox.rs | 418 +- crates/openshell-server/src/grpc/service.rs | 10 + crates/openshell-server/src/lib.rs | 1 + crates/openshell-server/tests/common/mod.rs | 58 + .../tests/supervisor_relay_integration.rs | 56 + .../src/token_grant.rs | 198 +- crates/openshell-tui/src/lib.rs | 1 + docs/reference/gateway-config.mdx | 2 + docs/sandboxes/providers-v2.mdx | 65 +- proto/openshell.proto | 201 +- sdk/go/proto/openshellv1/openshell.pb.go | 7826 ++++++++++------- sdk/go/proto/openshellv1/openshell_grpc.pb.go | 418 +- 36 files changed, 9261 insertions(+), 3456 deletions(-) create mode 100644 crates/openshell-server/src/delegated_identity.rs diff --git a/architecture/sandbox.md b/architecture/sandbox.md index b1209167c4..ae5daeab3b 100644 --- a/architecture/sandbox.md +++ b/architecture/sandbox.md @@ -338,13 +338,23 @@ Provider profiles can also declare dynamic token grants. For matching HTTP endpoints, the supervisor obtains or exchanges OAuth2 access tokens, caches them, and injects them before forwarding the request. `client_credentials` grants use the supervisor SPIFFE JWT-SVID directly as the client assertion. -`token_exchange` grants ask the gateway to broker an intermediate token using a -stored provider subject credential and the gateway's own SPIFFE JWT-SVID; the -supervisor then exchanges that intermediate token for the final upstream token -using its own JWT-SVID. The gateway validates that its own JWT-SVID has the +`token_exchange` grants ask the gateway to broker an intermediate token using +either a stored provider subject credential or the sandbox creator's delegated +OIDC identity, plus the gateway's own SPIFFE JWT-SVID; the supervisor then +exchanges that intermediate token for the final upstream token using its own +JWT-SVID. Delegated identity is opt-in at sandbox creation, stores one +gateway-scoped credential per issuer/client/user subject, and stores only a +per-sandbox authorization window on the sandbox. Only the delegating user can +extend or withdraw that window; workspace admins and platform admins can still +delete the sandbox to recover workspace resources. The gateway rejects exchange +after expiry, withdrawal, missing credential state, or credential revocation. +The gateway validates that its own JWT-SVID has the requested audience, a SPIFFE subject, and a non-expired `exp` claim when -present. It also validates that the stored subject credential is declared by the -provider profile, and that the supervisor JWT-SVID is a well-formed +present. For provider-credential subject tokens, it also validates that the +stored subject credential is declared by the provider profile. For delegated +identity subject tokens, it validates that the sandbox was created with active +delegation for the stored credential principal. The gateway also verifies that +the supervisor JWT-SVID is a well-formed three-segment JWT with a SPIFFE subject in the same trust domain as the gateway SVID. The gateway verifies the supervisor JWT-SVID signature with JWT bundles fetched from its SPIFFE Workload API. Token grant endpoints are HTTPS-only diff --git a/crates/openshell-cli/src/main.rs b/crates/openshell-cli/src/main.rs index d17e830969..7c2ed0804b 100644 --- a/crates/openshell-cli/src/main.rs +++ b/crates/openshell-cli/src/main.rs @@ -564,6 +564,13 @@ enum Commands { command: Option, }, + /// Manage delegated identity credential records. + #[command(help_template = SUBCOMMAND_HELP_TEMPLATE)] + DelegatedCredential { + #[command(subcommand)] + command: Option, + }, + /// Manage workspaces. #[command(alias = "ws", after_help = WORKSPACE_EXAMPLES, help_template = SUBCOMMAND_HELP_TEMPLATE)] Workspace { @@ -1102,6 +1109,62 @@ enum ProviderProfileCommands { }, } +#[derive(Subcommand, Debug)] +enum DelegatedCredentialCommands { + /// List delegated identity credentials. + #[command(help_template = LEAF_HELP_TEMPLATE, next_help_heading = "FLAGS")] + List { + /// Maximum number of credentials to return. + #[arg(long, default_value_t = 100)] + limit: u32, + + /// Number of credentials to skip. + #[arg(long, default_value_t = 0)] + offset: u32, + + /// Output only credential IDs. + #[arg(long, conflicts_with = "output")] + ids: bool, + + /// Output format. + #[arg(short = 'o', long = "output", value_enum, default_value_t = OutputFormat::Table, conflicts_with = "ids")] + output: OutputFormat, + }, + + /// Show delegated identity credential status. + #[command(help_template = LEAF_HELP_TEMPLATE, next_help_heading = "FLAGS")] + Status { + /// Delegated identity credential ID. + id: String, + + /// Output format. + #[arg(short = 'o', long = "output", value_enum, default_value_t = OutputFormat::Table)] + output: OutputFormat, + }, + + /// Revoke a delegated identity credential. + #[command(help_template = LEAF_HELP_TEMPLATE, next_help_heading = "FLAGS")] + Revoke { + /// Delegated identity credential ID. + id: String, + + /// Expected resource version for compare-and-swap updates. + #[arg(long = "resource-version", default_value_t = 0)] + resource_version: u64, + }, + + /// Delete a delegated identity credential record. + #[command(help_template = LEAF_HELP_TEMPLATE, next_help_heading = "FLAGS")] + Delete { + /// Delegated identity credential ID. + id: String, + + /// Expected resource version for compare-and-swap deletes. + #[arg(long = "resource-version", default_value_t = 0)] + resource_version: u64, + }, +} + // ----------------------------------------------------------------------- // Gateway commands (replaces the old `cluster` / `cluster admin` groups) // ----------------------------------------------------------------------- @@ -1413,6 +1476,11 @@ enum SandboxCommands { #[arg(long = "provider")] providers: Vec, + /// Delegate the current OIDC identity to the sandbox for a bounded duration. + /// Accepts positive durations with m, h, or d suffixes, for example 30m, 8h, or 7d. + #[arg(long = "delegate-identity-for", value_name = "DURATION")] + delegate_identity_for: Option, + /// Path to a custom sandbox policy YAML file. /// Overrides the built-in default and the `OPENSHELL_SANDBOX_POLICY` env var. #[arg(long, value_hint = ValueHint::FilePath)] @@ -1672,6 +1740,41 @@ enum SandboxCommands { /// Manage providers attached to a sandbox. #[command(subcommand)] Provider(SandboxProviderCommands), + + /// Manage sandbox delegated identity. + #[command(subcommand, name = "delegated-identity")] + DelegatedIdentity(SandboxDelegatedIdentityCommands), +} + +#[derive(Subcommand, Debug)] +enum SandboxDelegatedIdentityCommands { + /// Show delegated identity status for a sandbox. + #[command(help_template = LEAF_HELP_TEMPLATE, next_help_heading = "FLAGS")] + Status { + /// Sandbox name. + #[arg(add = ArgValueCompleter::new(completers::complete_sandbox_names))] + name: String, + }, + + /// Withdraw delegated identity from a sandbox. + #[command(help_template = LEAF_HELP_TEMPLATE, next_help_heading = "FLAGS")] + Withdraw { + /// Sandbox name. + #[arg(add = ArgValueCompleter::new(completers::complete_sandbox_names))] + name: String, + }, + + /// Set delegated identity expiry to now plus the requested duration. + #[command(help_template = LEAF_HELP_TEMPLATE, next_help_heading = "FLAGS")] + Extend { + /// Sandbox name. + #[arg(add = ArgValueCompleter::new(completers::complete_sandbox_names))] + name: String, + + /// New authorization window, for example 24h. + #[arg(long = "for", value_name = "DURATION")] + duration: String, + }, } #[derive(Subcommand, Debug)] @@ -2994,6 +3097,7 @@ async fn run_async() -> Result<()> { memory, driver_config_json, providers, + delegate_identity_for, policy, forward, tty, @@ -3085,6 +3189,7 @@ async fn run_async() -> Result<()> { driver_config_json: driver_config_json.as_deref(), editor, providers: &providers, + delegate_identity_for: delegate_identity_for.as_deref(), policy: policy.as_deref(), forward, command: &command, @@ -3304,6 +3409,37 @@ async fn run_async() -> Result<()> { .await?; } }, + SandboxCommands::DelegatedIdentity(command) => match command { + SandboxDelegatedIdentityCommands::Status { name } => { + run::sandbox_delegated_identity_status( + endpoint, + &name, + &cli.workspace, + &tls, + ) + .await?; + } + SandboxDelegatedIdentityCommands::Withdraw { name } => { + run::sandbox_delegated_identity_withdraw( + endpoint, + &name, + &cli.workspace, + &tls, + ) + .await?; + } + SandboxDelegatedIdentityCommands::Extend { name, duration } => { + run::sandbox_delegated_identity_extend( + endpoint, + &ctx.name, + &name, + &duration, + &cli.workspace, + &tls, + ) + .await?; + } + }, } } } @@ -3588,6 +3724,61 @@ async fn run_async() -> Result<()> { } } } + Some(Commands::DelegatedCredential { + command: Some(command), + }) => { + let ctx = resolve_gateway(&cli.gateway, &cli.gateway_endpoint)?; + let endpoint = &ctx.endpoint; + let mut tls = tls.with_gateway_name(&ctx.name); + apply_auth(&mut tls, &ctx.name); + + match command { + DelegatedCredentialCommands::List { + limit, + offset, + ids, + output, + } => { + run::delegated_identity_credential_list( + endpoint, + limit, + offset, + ids, + output.as_str(), + &tls, + ) + .await?; + } + DelegatedCredentialCommands::Status { id, output } => { + run::delegated_identity_credential_status(endpoint, &id, output.as_str(), &tls) + .await?; + } + DelegatedCredentialCommands::Revoke { + id, + resource_version, + } => { + run::delegated_identity_credential_revoke( + endpoint, + &id, + resource_version, + &tls, + ) + .await?; + } + DelegatedCredentialCommands::Delete { + id, + resource_version, + } => { + run::delegated_identity_credential_delete( + endpoint, + &id, + resource_version, + &tls, + ) + .await?; + } + } + } Some(Commands::Term { theme }) => { let ctx = resolve_gateway(&cli.gateway, &cli.gateway_endpoint)?; let mut tls = tls.with_gateway_name(&ctx.name); @@ -3719,6 +3910,13 @@ async fn run_async() -> Result<()> { .print_help() .expect("Failed to print help"); } + Some(Commands::DelegatedCredential { command: None }) => { + Cli::command() + .find_subcommand_mut("delegated-credential") + .expect("delegated-credential subcommand exists") + .print_help() + .expect("Failed to print help"); + } Some(Commands::Gateway { command: None }) => { Cli::command() .find_subcommand_mut("gateway") @@ -4439,6 +4637,60 @@ mod tests { )); } + #[test] + fn delegated_credential_commands_parse() { + let list = Cli::try_parse_from(["openshell", "delegated-credential", "list", "--ids"]) + .expect("delegated credential list should parse"); + assert!(matches!( + list.command, + Some(Commands::DelegatedCredential { + command: Some(DelegatedCredentialCommands::List { + ids: true, + output: OutputFormat::Table, + .. + }) + }) + )); + + let status = Cli::try_parse_from([ + "openshell", + "delegated-credential", + "status", + "delegated-identity-123", + "-o", + "json", + ]) + .expect("delegated credential status should parse"); + assert!(matches!( + status.command, + Some(Commands::DelegatedCredential { + command: Some(DelegatedCredentialCommands::Status { + id, + output: OutputFormat::Json, + }) + }) if id == "delegated-identity-123" + )); + + let revoke = Cli::try_parse_from([ + "openshell", + "delegated-credential", + "revoke", + "delegated-identity-123", + "--resource-version", + "7", + ]) + .expect("delegated credential revoke should parse"); + assert!(matches!( + revoke.command, + Some(Commands::DelegatedCredential { + command: Some(DelegatedCredentialCommands::Revoke { + id, + resource_version: 7, + }) + }) if id == "delegated-identity-123" + )); + } + #[test] fn provider_profile_commands_parse() { let export = Cli::try_parse_from([ diff --git a/crates/openshell-cli/src/run.rs b/crates/openshell-cli/src/run.rs index ae139ff665..b5878ff974 100644 --- a/crates/openshell-cli/src/run.rs +++ b/crates/openshell-cli/src/run.rs @@ -23,7 +23,7 @@ pub use crate::commands::gateway::{ }; use crate::policy_update::build_policy_update_plan; -use crate::tls::{TlsOptions, grpc_client, grpc_inference_client}; +use crate::tls::{GrpcClient, TlsOptions, grpc_client, grpc_inference_client}; use dialoguer::Confirm; use futures::StreamExt; use indicatif::{ProgressBar, ProgressStyle}; @@ -36,26 +36,30 @@ use openshell_core::proto::ProviderProfileCategory; use openshell_core::proto::{ ApproveAllDraftChunksRequest, ApproveDraftChunkRequest, AttachSandboxProviderRequest, ClearDraftChunksRequest, ConfigureProviderRefreshRequest, CreateProviderRequest, - CreateSandboxRequest, CreateSshSessionRequest, DeleteInferenceRouteRequest, - DeleteProviderProfileRequest, DeleteProviderRefreshRequest, DeleteProviderRequest, - DeleteSandboxRequest, DeleteServiceRequest, DetachSandboxProviderRequest, ExecSandboxRequest, - ExposeServiceRequest, GetCurrentUserRequest, GetDraftHistoryRequest, GetDraftPolicyRequest, + CreateSandboxRequest, CreateSshSessionRequest, DelegatedIdentityCredentialSummary, + DelegatedIdentityRequest, DeleteDelegatedIdentityCredentialRequest, + DeleteInferenceRouteRequest, DeleteProviderProfileRequest, DeleteProviderRefreshRequest, + DeleteProviderRequest, DeleteSandboxRequest, DeleteServiceRequest, + DetachSandboxProviderRequest, ExecSandboxRequest, ExposeServiceRequest, + ExtendSandboxDelegatedIdentityRequest, GetCurrentUserRequest, + GetDelegatedIdentityCredentialStatusRequest, GetDraftHistoryRequest, GetDraftPolicyRequest, GetGatewayConfigRequest, GetInferenceRouteRequest, GetProviderProfileRequest, GetProviderRefreshStatusRequest, GetProviderRequest, GetSandboxConfigRequest, - GetSandboxConfigResponse, GetSandboxLogsRequest, GetSandboxPolicyStatusRequest, - GetSandboxRequest, GetServiceRequest, GpuResourceRequirements, ImportProviderProfilesRequest, - LintProviderProfilesRequest, ListProviderProfilesRequest, ListProvidersRequest, + GetSandboxConfigResponse, GetSandboxDelegatedIdentityStatusRequest, GetSandboxLogsRequest, + GetSandboxPolicyStatusRequest, GetSandboxRequest, GetServiceRequest, GpuResourceRequirements, + ImportProviderProfilesRequest, LintProviderProfilesRequest, + ListDelegatedIdentityCredentialsRequest, ListProviderProfilesRequest, ListProvidersRequest, ListSandboxPoliciesRequest, ListSandboxProvidersRequest, ListSandboxesRequest, ListServicesRequest, PolicySource, PolicyStatus, Provider, ProviderCredentialRefreshRecoveryAction, ProviderCredentialRefreshStatus, ProviderCredentialRefreshStrategy, ProviderCredentialTokenGrantType, ProviderProfile, ProviderProfileDiagnostic, ProviderProfileImportItem, RejectDraftChunkRequest, - ResourceRequirements, RevokeSshSessionRequest, RotateProviderCredentialRequest, Sandbox, - SandboxPhase, SandboxPolicy, SandboxSpec, SandboxTemplate, ServiceEndpointResponse, - SetInferenceRouteRequest, SettingScope, StartSandboxRequest, StopSandboxRequest, - TcpForwardFrame, TcpForwardInit, TcpRelayTarget, UpdateConfigRequest, - UpdateProviderProfilesRequest, UpdateProviderRequest, WatchSandboxRequest, exec_sandbox_event, - setting_value, tcp_forward_init, + ResourceRequirements, RevokeDelegatedIdentityCredentialRequest, RevokeSshSessionRequest, + RotateProviderCredentialRequest, Sandbox, SandboxPhase, SandboxPolicy, SandboxSpec, + SandboxTemplate, ServiceEndpointResponse, SetInferenceRouteRequest, SettingScope, + StartSandboxRequest, StopSandboxRequest, TcpForwardFrame, TcpForwardInit, TcpRelayTarget, + UpdateConfigRequest, UpdateProviderProfilesRequest, UpdateProviderRequest, WatchSandboxRequest, + WithdrawSandboxDelegatedIdentityRequest, exec_sandbox_event, setting_value, tcp_forward_init, }; use openshell_core::settings; use openshell_core::{ObjectId, ObjectName, ObjectWorkspace}; @@ -405,6 +409,7 @@ pub struct SandboxCreateConfig<'a> { pub approval_mode: &'a str, pub output: &'a str, pub detach: bool, + pub delegate_identity_for: Option<&'a str>, } impl Default for SandboxCreateConfig<'_> { @@ -430,6 +435,7 @@ impl Default for SandboxCreateConfig<'_> { approval_mode: "manual", output: "table", detach: false, + delegate_identity_for: None, } } } @@ -463,6 +469,7 @@ pub async fn sandbox_create( approval_mode, output, detach, + delegate_identity_for, } = config; if editor.is_some() && !command.is_empty() { @@ -535,6 +542,9 @@ pub async fn sandbox_create( workspace, ) .await?; + if delegate_identity_for.is_none() { + warn_delegated_identity_profiles(&mut client, &configured_providers, workspace).await?; + } let policy = load_sandbox_policy(policy)?; let resource_limits = build_sandbox_resource_limits(cpu, memory)?; @@ -554,6 +564,8 @@ pub async fn sandbox_create( }; let resource_requirements = gpu_requirements.map(|gpu| ResourceRequirements { gpu: Some(gpu) }); + let delegated_identity = + delegated_identity_request(gateway_name, tls, delegate_identity_for).await?; let main_terminal = tty_override .unwrap_or_else(|| std::io::stdin().is_terminal() && std::io::stdout().is_terminal()); @@ -592,6 +604,7 @@ pub async fn sandbox_create( annotations, workspace: workspace.to_string(), await_main_process_attachment, + delegated_identity, }; let response = match client.create_sandbox(request).await { @@ -1335,6 +1348,622 @@ pub async fn sandbox_sync_command( Ok(()) } +async fn delegated_identity_request( + gateway_name: &str, + tls: &TlsOptions, + duration: Option<&str>, +) -> Result> { + let Some(duration) = duration else { + return Ok(None); + }; + let duration_ms = parse_delegated_identity_duration_ms(duration)?; + let bundle = + crate::oidc_auth::ensure_valid_oidc_token_bundle(gateway_name, tls.gateway_insecure) + .await + .map_err(|err| { + miette::miette!( + "failed to load or refresh OIDC token for delegated identity: {err}" + ) + })?; + let scopes = openshell_bootstrap::load_gateway_metadata(gateway_name) + .ok() + .and_then(|metadata| metadata.oidc_scopes); + let bundle = + crate::oidc_auth::oidc_refresh_token(&bundle, scopes.as_deref(), tls.gateway_insecure) + .await + .and_then(|refreshed| { + openshell_bootstrap::oidc_token::store_oidc_token(gateway_name, &refreshed)?; + Ok(refreshed) + }) + .map_err(|err| { + miette::miette!( + "failed to refresh local OIDC token for delegated identity: {err}\n\ + Re-authenticate with `openshell gateway logout` followed by `openshell gateway login`, then retry this command." + ) + })?; + let refresh_token = bundle.refresh_token.ok_or_else(|| { + miette::miette!( + "--delegate-identity-for requires a local OIDC refresh token; run `openshell gateway login` and ensure the gateway OIDC client issues refresh tokens" + ) + })?; + let now_ms = current_time_ms(); + Ok(Some(DelegatedIdentityRequest { + delegated_until_ms: now_ms.saturating_add(duration_ms), + issuer: bundle.issuer, + client_id: bundle.client_id, + refresh_token, + access_token: bundle.access_token, + scopes: scopes.unwrap_or_default(), + audience: openshell_bootstrap::load_gateway_metadata(gateway_name) + .ok() + .and_then(|metadata| metadata.oidc_audience) + .unwrap_or_default(), + })) +} + +fn parse_delegated_identity_duration_ms(value: &str) -> Result { + let value = value.trim(); + let (number, multiplier): (&str, i64) = match value.as_bytes().last().copied() { + Some(b'm') => (&value[..value.len() - 1], 60_000), + Some(b'h') => (&value[..value.len() - 1], 3_600_000), + Some(b'd') => (&value[..value.len() - 1], 86_400_000), + _ => { + return Err(miette::miette!( + "invalid delegated identity duration '{value}'; use a positive duration with m, h, or d suffix" + )); + } + }; + let amount = number.parse::().map_err(|_| { + miette::miette!( + "invalid delegated identity duration '{value}'; use a positive integer with m, h, or d suffix" + ) + })?; + if amount <= 0 { + return Err(miette::miette!( + "delegated identity duration must be greater than zero" + )); + } + amount + .checked_mul(multiplier) + .ok_or_else(|| miette::miette!("delegated identity duration is too large")) +} + +fn current_time_ms() -> i64 { + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap_or_default() + .as_millis() + .try_into() + .unwrap_or(i64::MAX) +} + +async fn warn_delegated_identity_profiles( + client: &mut GrpcClient, + provider_names: &[String], + workspace: &str, +) -> Result<()> { + for provider_name in provider_names { + let provider = client + .get_provider(GetProviderRequest { + name: provider_name.clone(), + workspace: workspace.to_string(), + }) + .await + .map_err(|status| miette::miette!(status.to_string()))? + .into_inner() + .provider; + let Some(provider) = provider else { + continue; + }; + let profile_id = normalize_provider_type(&provider.r#type).unwrap_or(&provider.r#type); + let profile = client + .get_provider_profile(GetProviderProfileRequest { + id: profile_id.to_string(), + workspace: provider.profile_workspace.clone(), + }) + .await + .ok() + .and_then(|response| response.into_inner().profile); + let Some(profile) = profile else { + continue; + }; + if profile_uses_sandbox_delegated_identity(&profile) { + eprintln!( + "Provider '{provider_name}' uses sandbox delegated identity. Token exchange will fail because this sandbox was not created with delegated identity. Delete and recreate the sandbox with --delegate-identity-for= to enable it." + ); + } + } + Ok(()) +} + +fn profile_uses_sandbox_delegated_identity(profile: &ProviderProfile) -> bool { + profile.credentials.iter().any(|credential| { + credential + .token_grant + .as_ref() + .and_then(|grant| grant.subject_token.as_ref()) + .is_some_and(|subject| subject.source == "sandbox_delegated_identity") + }) +} + +pub async fn sandbox_delegated_identity_status( + server: &str, + name: &str, + workspace: &str, + tls: &TlsOptions, +) -> Result<()> { + let mut client = grpc_client(server, tls).await?; + let response = client + .get_sandbox_delegated_identity_status(GetSandboxDelegatedIdentityStatusRequest { + name: name.to_string(), + workspace: workspace.to_string(), + }) + .await + .map_err(|status| miette::miette!(status.to_string()))? + .into_inner(); + let Some(delegation) = response.delegated_identity else { + println!("Delegated identity: disabled"); + return Ok(()); + }; + let status = sandbox_delegation_status( + response.credential_missing, + response.credential_revoked_at_ms, + delegation.withdrawn_at_ms, + delegation.delegated_until_ms, + response.now_ms, + ); + println!("Delegated identity: enabled"); + println!("Credential ID: {}", delegation.credential_id); + println!("Principal: {}", delegation.principal_subject); + println!("Status: {status}"); + match status { + "active" => println!( + "Valid for: {}", + format_remaining_duration(delegation.delegated_until_ms, response.now_ms) + ), + "withdrawn" => println!( + "Withdrawn: {}", + format_age(delegation.withdrawn_at_ms, response.now_ms) + ), + "revoked" => println!( + "Revoked: {}", + format_age(response.credential_revoked_at_ms, response.now_ms) + ), + "credential-missing" => println!("Credential: missing"), + "expired" => println!( + "Expired: {}", + format_age(delegation.delegated_until_ms, response.now_ms) + ), + _ => {} + } + Ok(()) +} + +pub async fn sandbox_delegated_identity_withdraw( + server: &str, + name: &str, + workspace: &str, + tls: &TlsOptions, +) -> Result<()> { + let mut client = grpc_client(server, tls).await?; + let response = client + .withdraw_sandbox_delegated_identity(WithdrawSandboxDelegatedIdentityRequest { + name: name.to_string(), + workspace: workspace.to_string(), + }) + .await + .map_err(|status| miette::miette!(status.to_string()))? + .into_inner(); + let action = if response.withdrawn { + "Withdrew" + } else { + "Already withdrawn" + }; + println!("{action} delegated identity for sandbox {name}"); + Ok(()) +} + +pub async fn sandbox_delegated_identity_extend( + server: &str, + gateway_name: &str, + name: &str, + duration: &str, + workspace: &str, + tls: &TlsOptions, +) -> Result<()> { + let mut client = grpc_client(server, tls).await?; + let delegated_identity = delegated_identity_request(gateway_name, tls, Some(duration)) + .await? + .expect("duration was provided"); + let response = client + .extend_sandbox_delegated_identity(ExtendSandboxDelegatedIdentityRequest { + name: name.to_string(), + workspace: workspace.to_string(), + delegated_identity: Some(delegated_identity), + }) + .await + .map_err(|status| miette::miette!(status.to_string()))? + .into_inner(); + let sandbox_name = response + .sandbox + .as_ref() + .map(ObjectName::object_name) + .filter(|name| !name.is_empty()) + .unwrap_or(name); + println!("Extended delegated identity for sandbox {sandbox_name}"); + Ok(()) +} + +pub async fn delegated_identity_credential_list( + server: &str, + limit: u32, + offset: u32, + ids_only: bool, + output: &str, + tls: &TlsOptions, +) -> Result<()> { + let mut client = grpc_client(server, tls).await?; + let credentials = client + .list_delegated_identity_credentials(ListDelegatedIdentityCredentialsRequest { + limit, + offset, + }) + .await + .map_err(|status| miette::miette!(status.to_string()))? + .into_inner() + .credentials; + + if crate::output::print_output_collection( + output, + &credentials, + delegated_identity_credential_to_json, + )? { + return Ok(()); + } + + if credentials.is_empty() { + if !ids_only { + println!("No delegated identity credentials found."); + } + return Ok(()); + } + + if ids_only { + for credential in credentials { + println!("{}", delegated_credential_object_id(&credential)); + } + return Ok(()); + } + + print_delegated_identity_credential_table(&credentials, current_time_ms()); + Ok(()) +} + +pub async fn delegated_identity_credential_status( + server: &str, + id: &str, + output: &str, + tls: &TlsOptions, +) -> Result<()> { + let mut client = grpc_client(server, tls).await?; + let response = client + .get_delegated_identity_credential_status(GetDelegatedIdentityCredentialStatusRequest { + id: id.to_string(), + }) + .await + .map_err(|status| miette::miette!(status.to_string()))? + .into_inner(); + let credential = response + .credential + .ok_or_else(|| miette::miette!("delegated identity credential missing from response"))?; + let view = serde_json::json!({ + "credential": delegated_identity_credential_to_json(&credential), + "now_ms": response.now_ms, + }); + if crate::output::print_output_single(output, &view, Clone::clone)? { + return Ok(()); + } + + println!("{}", "Delegated identity credential:".cyan().bold()); + println!(); + print_delegated_identity_credential_detail(&credential, response.now_ms); + Ok(()) +} + +pub async fn delegated_identity_credential_revoke( + server: &str, + id: &str, + expected_resource_version: u64, + tls: &TlsOptions, +) -> Result<()> { + let mut client = grpc_client(server, tls).await?; + let response = client + .revoke_delegated_identity_credential(RevokeDelegatedIdentityCredentialRequest { + id: id.to_string(), + expected_resource_version, + }) + .await + .map_err(|status| miette::miette!(status.to_string()))? + .into_inner(); + if response.revoked { + println!("Revoked delegated identity credential {id}"); + } else { + println!("Delegated identity credential {id} was already revoked"); + } + Ok(()) +} + +pub async fn delegated_identity_credential_delete( + server: &str, + id: &str, + expected_resource_version: u64, + tls: &TlsOptions, +) -> Result<()> { + let mut client = grpc_client(server, tls).await?; + let response = client + .delete_delegated_identity_credential(DeleteDelegatedIdentityCredentialRequest { + id: id.to_string(), + expected_resource_version, + }) + .await + .map_err(|status| miette::miette!(status.to_string()))? + .into_inner(); + if response.deleted { + println!("Deleted delegated identity credential {id}"); + } else { + println!("Delegated identity credential {id} was not found"); + } + Ok(()) +} + +fn delegated_identity_credential_to_json( + credential: &DelegatedIdentityCredentialSummary, +) -> serde_json::Value { + let metadata = credential.metadata.as_ref(); + serde_json::json!({ + "id": delegated_credential_object_id(credential), + "name": delegated_credential_object_name(credential), + "workspace": delegated_credential_object_workspace(credential), + "resource_version": metadata.map(|meta| meta.resource_version).unwrap_or_default(), + "created_at_ms": metadata.map(|meta| meta.created_at_ms).unwrap_or_default(), + "issuer": credential.issuer, + "client_id": credential.client_id, + "principal_subject": credential.principal_subject, + "access_token_present": credential.access_token_present, + "refresh_token_present": credential.refresh_token_present, + "access_token_expires_at_ms": credential.access_token_expires_at_ms, + "scopes": credential.scopes, + "audience": credential.audience, + "last_refresh_at_ms": credential.last_refresh_at_ms, + "revoked_at_ms": credential.revoked_at_ms, + }) +} + +fn print_delegated_identity_credential_table( + credentials: &[DelegatedIdentityCredentialSummary], + now: i64, +) { + println!( + "{:<84} {:<40} {:<24} {:<10} {:<16} {:<14} {:>8}", + "ID", "PRINCIPAL", "CLIENT_ID", "STATUS", "ACCESS_VALID_FOR", "LAST_REFRESH", "RV" + ); + println!("{}", "-".repeat(208)); + for credential in credentials { + let resource_version = credential + .metadata + .as_ref() + .map(|meta| meta.resource_version) + .unwrap_or_default(); + println!( + "{:<84} {:<40} {:<24} {:<10} {:<16} {:<14} {:>8}", + delegated_credential_object_id(credential), + credential.principal_subject, + truncate_for_table(&credential.client_id, 24), + delegated_credential_status(credential, now), + credential_access_valid_for(credential, now), + format_optional_age(credential.last_refresh_at_ms, now), + resource_version, + ); + } +} + +fn print_delegated_identity_credential_detail( + credential: &DelegatedIdentityCredentialSummary, + now: i64, +) { + let metadata = credential.metadata.as_ref(); + println!( + " {:<22} {}", + "id:", + delegated_credential_object_id(credential) + ); + println!(" {:<22} {}", "issuer:", credential.issuer); + println!(" {:<22} {}", "client_id:", credential.client_id); + println!( + " {:<22} {}", + "principal_subject:", credential.principal_subject + ); + println!( + " {:<22} {}", + "resource_version:", + metadata + .map(|meta| meta.resource_version) + .unwrap_or_default() + ); + println!( + " {:<22} {}", + "created_at_ms:", + metadata.map(|meta| meta.created_at_ms).unwrap_or_default() + ); + println!( + " {:<22} {}", + "access_token_present:", credential.access_token_present + ); + println!( + " {:<22} {}", + "refresh_token_present:", credential.refresh_token_present + ); + println!( + " {:<22} {}", + "status:", + delegated_credential_status(credential, now) + ); + println!( + " {:<22} {}", + "access_valid_for:", + credential_access_valid_for(credential, now) + ); + println!(" {:<22} {}", "scopes:", credential.scopes); + println!(" {:<22} {}", "audience:", credential.audience); + println!( + " {:<22} {}", + "last_refresh:", + format_optional_age(credential.last_refresh_at_ms, now) + ); + if credential.revoked_at_ms > 0 { + println!( + " {:<22} {}", + "revoked:", + format_age(credential.revoked_at_ms, now) + ); + } +} + +fn sandbox_delegation_status( + credential_missing: bool, + credential_revoked_at_ms: i64, + withdrawn_at_ms: i64, + delegated_until_ms: i64, + now_ms: i64, +) -> &'static str { + if credential_missing { + "credential-missing" + } else if credential_revoked_at_ms > 0 { + "revoked" + } else if withdrawn_at_ms > 0 { + "withdrawn" + } else if delegated_until_ms <= now_ms { + "expired" + } else { + "active" + } +} + +fn delegated_credential_status( + credential: &DelegatedIdentityCredentialSummary, + now: i64, +) -> &'static str { + if credential.revoked_at_ms > 0 { + "revoked" + } else if credential.access_token_expires_at_ms > 0 + && credential.access_token_expires_at_ms <= now + { + "expired" + } else { + "active" + } +} + +fn delegated_credential_object_id(credential: &DelegatedIdentityCredentialSummary) -> &str { + credential + .metadata + .as_ref() + .map(|metadata| metadata.id.as_str()) + .unwrap_or_default() +} + +fn delegated_credential_object_name(credential: &DelegatedIdentityCredentialSummary) -> &str { + credential + .metadata + .as_ref() + .map(|metadata| metadata.name.as_str()) + .unwrap_or_default() +} + +fn delegated_credential_object_workspace(credential: &DelegatedIdentityCredentialSummary) -> &str { + credential + .metadata + .as_ref() + .map(|metadata| metadata.workspace.as_str()) + .unwrap_or_default() +} + +fn credential_access_valid_for( + credential: &DelegatedIdentityCredentialSummary, + now: i64, +) -> String { + if delegated_credential_status(credential, now) != "active" { + "-".to_string() + } else if credential.access_token_expires_at_ms == 0 { + "unknown".to_string() + } else { + format_remaining_duration(credential.access_token_expires_at_ms, now) + } +} + +fn format_remaining_duration(until_ms: i64, now_ms: i64) -> String { + if until_ms <= now_ms { + "-".to_string() + } else { + format_compact_duration_ms(until_ms.saturating_sub(now_ms)) + } +} + +fn format_optional_age(timestamp_ms: i64, now_ms: i64) -> String { + if timestamp_ms > 0 { + format_age(timestamp_ms, now_ms) + } else { + "never".to_string() + } +} + +fn format_age(timestamp_ms: i64, now_ms: i64) -> String { + if timestamp_ms <= 0 { + return "never".to_string(); + } + if timestamp_ms > now_ms { + return format!( + "in {}", + format_compact_duration_ms(timestamp_ms.saturating_sub(now_ms)) + ); + } + format!( + "{} ago", + format_compact_duration_ms(now_ms.saturating_sub(timestamp_ms)) + ) +} + +fn format_compact_duration_ms(duration_ms: i64) -> String { + let seconds = duration_ms.saturating_add(999) / 1000; + if seconds < 60 { + return format!("{}s", seconds.max(0)); + } + let minutes = seconds / 60; + if minutes < 60 { + return format!("{minutes}m"); + } + let hours = minutes / 60; + if hours < 48 { + return format!("{hours}h"); + } + let days = hours / 24; + format!("{days}d") +} + +fn truncate_for_table(value: &str, max_len: usize) -> String { + if value.len() <= max_len { + value.to_string() + } else if max_len <= 1 { + ".".to_string() + } else { + let prefix = value + .chars() + .take(max_len.saturating_sub(3)) + .collect::(); + format!("{prefix}...") + } +} + /// Fetch a sandbox by name. /// /// Policy always comes from [`GetSandboxConfig`] (effective active policy, sandbox @@ -1692,7 +2321,7 @@ pub async fn service_forward_tcp( } async fn create_forward_session_token( - client: &mut crate::tls::GrpcClient, + client: &mut GrpcClient, sandbox_id: &str, ) -> std::result::Result { let response = client @@ -1705,7 +2334,7 @@ async fn create_forward_session_token( } async fn fetch_ready_sandbox_for_forward( - client: &mut crate::tls::GrpcClient, + client: &mut GrpcClient, name: &str, workspace: &str, ) -> Result { @@ -1795,7 +2424,7 @@ fn parse_tcp_forward_spec(local: Option<&str>, default_port: u16) -> Result<(Str } async fn forward_one_tcp_connection( - client: &mut crate::tls::GrpcClient, + client: &mut GrpcClient, socket: tokio::net::TcpStream, sandbox_id: String, target_host: String, @@ -1909,7 +2538,7 @@ impl Drop for TaskGuard { } async fn sandbox_exec_interactive_grpc( - mut client: crate::tls::GrpcClient, + mut client: GrpcClient, sandbox: &Sandbox, command: &[String], workdir: Option<&str>, @@ -2569,7 +3198,7 @@ pub async fn sandbox_start( } async fn wait_for_lifecycle_phase( - client: &mut crate::tls::GrpcClient, + client: &mut GrpcClient, sandbox: Sandbox, target: SandboxPhase, ) -> Result { @@ -2659,7 +3288,7 @@ fn inferred_provider_type(command: &[String]) -> Option { /// Returns a deduplicated list of provider **names** suitable for /// `SandboxSpec.providers`. pub async fn ensure_required_providers( - client: &mut crate::tls::GrpcClient, + client: &mut GrpcClient, explicit_names: &[String], inferred_types: &[String], auto_providers_override: Option, @@ -2781,7 +3410,7 @@ pub async fn ensure_required_providers( /// defaults to the type and retries with suffixes on conflict (used for /// inferred provider types). async fn auto_create_provider( - client: &mut crate::tls::GrpcClient, + client: &mut GrpcClient, provider_type: &str, preferred_name: Option<&str>, auto_providers_override: Option, @@ -3307,7 +3936,7 @@ fn read_gcloud_adc() -> Result<(String, String, String)> { } async fn rollback_provider_create_after_gcloud_adc_failure( - client: &mut crate::tls::GrpcClient, + client: &mut GrpcClient, provider_name: &str, stage: &str, source: &Status, @@ -3361,7 +3990,7 @@ fn service_url_for_gateway(service_url: &str, gateway_endpoint: &str) -> String service_url.to_string() } -async fn gateway_providers_v2_enabled(client: &mut crate::tls::GrpcClient) -> Result { +async fn gateway_providers_v2_enabled(client: &mut GrpcClient) -> Result { let response = client .get_gateway_config(GetGatewayConfigRequest {}) .await @@ -3381,7 +4010,7 @@ async fn gateway_providers_v2_enabled(client: &mut crate::tls::GrpcClient) -> Re } async fn fetch_provider_profile( - client: &mut crate::tls::GrpcClient, + client: &mut GrpcClient, provider_type: &str, workspace: &str, ) -> Result { @@ -3408,7 +4037,7 @@ async fn fetch_provider_profile( } async fn discover_existing_provider_data( - client: &mut crate::tls::GrpcClient, + client: &mut GrpcClient, provider_type: &str, workspace: &str, ) -> Result> { @@ -8969,4 +9598,63 @@ mod tests { assert!(json["revision"].is_null()); assert!(json["policy"].is_null()); } + + #[test] + fn delegated_identity_human_status_formats_are_state_oriented() { + let now = 10_000; + assert_eq!( + super::sandbox_delegation_status(false, 0, 0, 70_000, now), + "active" + ); + assert_eq!( + super::sandbox_delegation_status(false, 0, 9_000, 70_000, now), + "withdrawn" + ); + assert_eq!( + super::sandbox_delegation_status(false, 0, 0, 9_000, now), + "expired" + ); + assert_eq!( + super::sandbox_delegation_status(false, 8_000, 0, 70_000, now), + "revoked" + ); + assert_eq!( + super::sandbox_delegation_status(true, 0, 0, 70_000, now), + "credential-missing" + ); + + assert_eq!(super::format_remaining_duration(70_000, now), "1m"); + assert_eq!(super::format_age(7_000, now), "3s ago"); + assert_eq!(super::format_optional_age(0, now), "never"); + } + + #[test] + fn delegated_identity_credential_status_formats_are_redacted_and_readable() { + let now = 10_000; + let mut credential = openshell_core::proto::DelegatedIdentityCredentialSummary { + access_token_expires_at_ms: 70_000, + last_refresh_at_ms: 5_000, + ..Default::default() + }; + + assert_eq!( + super::delegated_credential_status(&credential, now), + "active" + ); + assert_eq!(super::credential_access_valid_for(&credential, now), "1m"); + + credential.access_token_expires_at_ms = 9_000; + assert_eq!( + super::delegated_credential_status(&credential, now), + "expired" + ); + assert_eq!(super::credential_access_valid_for(&credential, now), "-"); + + credential.revoked_at_ms = 8_000; + assert_eq!( + super::delegated_credential_status(&credential, now), + "revoked" + ); + assert_eq!(super::credential_access_valid_for(&credential, now), "-"); + } } diff --git a/crates/openshell-cli/tests/ensure_providers_integration.rs b/crates/openshell-cli/tests/ensure_providers_integration.rs index 9999a7c083..687bb78caf 100644 --- a/crates/openshell-cli/tests/ensure_providers_integration.rs +++ b/crates/openshell-cli/tests/ensure_providers_integration.rs @@ -140,6 +140,64 @@ impl OpenShell for TestOpenShell { Err(Status::unimplemented("unused")) } + async fn get_sandbox_delegated_identity_status( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn withdraw_sandbox_delegated_identity( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn extend_sandbox_delegated_identity( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn list_delegated_identity_credentials( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn get_delegated_identity_credential_status( + &self, + _request: tonic::Request< + openshell_core::proto::GetDelegatedIdentityCredentialStatusRequest, + >, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn revoke_delegated_identity_credential( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn delete_delegated_identity_credential( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + async fn get_sandbox( &self, _request: tonic::Request, diff --git a/crates/openshell-cli/tests/mtls_integration.rs b/crates/openshell-cli/tests/mtls_integration.rs index e4735ac4c1..66bfc7d170 100644 --- a/crates/openshell-cli/tests/mtls_integration.rs +++ b/crates/openshell-cli/tests/mtls_integration.rs @@ -95,6 +95,64 @@ impl OpenShell for TestOpenShell { Err(Status::unimplemented("unused")) } + async fn get_sandbox_delegated_identity_status( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn withdraw_sandbox_delegated_identity( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn extend_sandbox_delegated_identity( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn list_delegated_identity_credentials( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn get_delegated_identity_credential_status( + &self, + _request: tonic::Request< + openshell_core::proto::GetDelegatedIdentityCredentialStatusRequest, + >, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn revoke_delegated_identity_credential( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn delete_delegated_identity_credential( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + async fn get_sandbox( &self, _request: tonic::Request, diff --git a/crates/openshell-cli/tests/provider_commands_integration.rs b/crates/openshell-cli/tests/provider_commands_integration.rs index 84fb8f9163..f20577b834 100644 --- a/crates/openshell-cli/tests/provider_commands_integration.rs +++ b/crates/openshell-cli/tests/provider_commands_integration.rs @@ -161,6 +161,64 @@ impl OpenShell for TestOpenShell { Err(Status::unimplemented("unused")) } + async fn get_sandbox_delegated_identity_status( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn withdraw_sandbox_delegated_identity( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn extend_sandbox_delegated_identity( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn list_delegated_identity_credentials( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn get_delegated_identity_credential_status( + &self, + _request: tonic::Request< + openshell_core::proto::GetDelegatedIdentityCredentialStatusRequest, + >, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn revoke_delegated_identity_credential( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn delete_delegated_identity_credential( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + async fn get_sandbox( &self, request: tonic::Request, diff --git a/crates/openshell-cli/tests/sandbox_create_lifecycle_integration.rs b/crates/openshell-cli/tests/sandbox_create_lifecycle_integration.rs index 118daff902..26275cb408 100644 --- a/crates/openshell-cli/tests/sandbox_create_lifecycle_integration.rs +++ b/crates/openshell-cli/tests/sandbox_create_lifecycle_integration.rs @@ -149,6 +149,64 @@ impl OpenShell for TestOpenShell { Err(Status::unimplemented("unused")) } + async fn get_sandbox_delegated_identity_status( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn withdraw_sandbox_delegated_identity( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn extend_sandbox_delegated_identity( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn list_delegated_identity_credentials( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn get_delegated_identity_credential_status( + &self, + _request: tonic::Request< + openshell_core::proto::GetDelegatedIdentityCredentialStatusRequest, + >, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn revoke_delegated_identity_credential( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn delete_delegated_identity_credential( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + async fn get_sandbox( &self, request: tonic::Request, diff --git a/crates/openshell-cli/tests/sandbox_name_fallback_integration.rs b/crates/openshell-cli/tests/sandbox_name_fallback_integration.rs index ee72728aa9..173a95cc5c 100644 --- a/crates/openshell-cli/tests/sandbox_name_fallback_integration.rs +++ b/crates/openshell-cli/tests/sandbox_name_fallback_integration.rs @@ -108,6 +108,64 @@ impl OpenShell for TestOpenShell { Err(Status::unimplemented("unused")) } + async fn get_sandbox_delegated_identity_status( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn withdraw_sandbox_delegated_identity( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn extend_sandbox_delegated_identity( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn list_delegated_identity_credentials( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn get_delegated_identity_credential_status( + &self, + _request: tonic::Request< + openshell_core::proto::GetDelegatedIdentityCredentialStatusRequest, + >, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn revoke_delegated_identity_credential( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn delete_delegated_identity_credential( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + async fn get_sandbox( &self, request: tonic::Request, diff --git a/crates/openshell-core/src/config.rs b/crates/openshell-core/src/config.rs index e04e056033..b3ed141b92 100644 --- a/crates/openshell-core/src/config.rs +++ b/crates/openshell-core/src/config.rs @@ -41,6 +41,9 @@ pub const DEFAULT_DOCKER_NETWORK_NAME: &str = "openshell-docker"; /// Default domain used for browser-facing sandbox service URLs. pub const DEFAULT_SERVICE_ROUTING_DOMAIN: &str = "openshell.localhost"; +/// Default maximum delegated identity authorization window for one sandbox. +pub const DEFAULT_MAX_DELEGATED_IDENTITY_DURATION_SECS: u64 = 86_400; + /// Gateway posture when a sandbox rejects a candidate policy generation. #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] @@ -840,6 +843,9 @@ pub struct Config { /// TTL for SSH session tokens, in seconds. 0 disables expiry. pub ssh_session_ttl_secs: u64, + /// Maximum delegated identity authorization window for one sandbox. + pub max_delegated_identity_duration_secs: u64, + /// Maximum gRPC requests allowed per rate-limit window. /// /// When paired with [`Self::grpc_rate_limit_window_secs`], positive values @@ -1196,6 +1202,7 @@ impl Config { credential_drivers: Vec::new(), default_credential_driver: None, ssh_session_ttl_secs: default_ssh_session_ttl_secs(), + max_delegated_identity_duration_secs: DEFAULT_MAX_DELEGATED_IDENTITY_DURATION_SECS, grpc_rate_limit_requests: None, grpc_rate_limit_window_secs: None, service_routing: ServiceRoutingConfig::default(), @@ -1293,6 +1300,13 @@ impl Config { self } + /// Create a new configuration with the maximum delegated identity duration. + #[must_use] + pub const fn with_max_delegated_identity_duration_secs(mut self, secs: u64) -> Self { + self.max_delegated_identity_duration_secs = secs; + self + } + /// Set the gateway-wide gRPC request rate limit. #[must_use] pub const fn with_grpc_rate_limit( diff --git a/crates/openshell-core/src/metadata.rs b/crates/openshell-core/src/metadata.rs index 8794c11d5d..c2fe720026 100644 --- a/crates/openshell-core/src/metadata.rs +++ b/crates/openshell-core/src/metadata.rs @@ -6,7 +6,8 @@ //! These traits provide uniform access to `ObjectMeta` fields across all resource types. use crate::proto::{ - InferenceRoute, ObjectForTest, Provider, Sandbox, SandboxStatus, ServiceEndpoint, SshSession, + DelegatedIdentityCredential, InferenceRoute, ObjectForTest, Provider, Sandbox, + SandboxDelegatedIdentityRecord, SandboxStatus, ServiceEndpoint, SshSession, StoredProviderCredentialRefreshState, StoredProviderProfile, Workspace, WorkspaceMember, }; use std::collections::HashMap; @@ -273,6 +274,90 @@ impl ObjectWorkspace for StoredProviderCredentialRefreshState { } } +// Implementations for DelegatedIdentityCredential +impl ObjectId for DelegatedIdentityCredential { + fn object_id(&self) -> &str { + self.metadata.as_ref().map_or("", |m| m.id.as_str()) + } +} + +impl ObjectName for DelegatedIdentityCredential { + fn object_name(&self) -> &str { + self.metadata.as_ref().map_or("", |m| m.name.as_str()) + } +} + +impl ObjectLabels for DelegatedIdentityCredential { + fn object_labels(&self) -> Option> { + self.metadata.as_ref().map(|m| m.labels.clone()) + } +} + +impl SetResourceVersion for DelegatedIdentityCredential { + fn set_resource_version(&mut self, version: u64) { + if let Some(meta) = self.metadata.as_mut() { + meta.resource_version = version; + } + } +} + +impl GetResourceVersion for DelegatedIdentityCredential { + fn get_resource_version(&self) -> u64 { + self.metadata.as_ref().map_or(0, |m| m.resource_version) + } +} + +impl ObjectWorkspace for DelegatedIdentityCredential { + fn object_workspace(&self) -> &str { + self.metadata.as_ref().map_or("", |m| m.workspace.as_str()) + } + fn requires_workspace() -> bool { + false + } +} + +// Implementations for SandboxDelegatedIdentityRecord +impl ObjectId for SandboxDelegatedIdentityRecord { + fn object_id(&self) -> &str { + self.metadata.as_ref().map_or("", |m| m.id.as_str()) + } +} + +impl ObjectName for SandboxDelegatedIdentityRecord { + fn object_name(&self) -> &str { + self.metadata.as_ref().map_or("", |m| m.name.as_str()) + } +} + +impl ObjectLabels for SandboxDelegatedIdentityRecord { + fn object_labels(&self) -> Option> { + self.metadata.as_ref().map(|m| m.labels.clone()) + } +} + +impl SetResourceVersion for SandboxDelegatedIdentityRecord { + fn set_resource_version(&mut self, version: u64) { + if let Some(meta) = self.metadata.as_mut() { + meta.resource_version = version; + } + } +} + +impl GetResourceVersion for SandboxDelegatedIdentityRecord { + fn get_resource_version(&self) -> u64 { + self.metadata.as_ref().map_or(0, |m| m.resource_version) + } +} + +impl ObjectWorkspace for SandboxDelegatedIdentityRecord { + fn object_workspace(&self) -> &str { + self.metadata.as_ref().map_or("", |m| m.workspace.as_str()) + } + fn requires_workspace() -> bool { + true + } +} + // Implementations for SshSession impl ObjectId for SshSession { fn object_id(&self) -> &str { diff --git a/crates/openshell-core/src/oauth.rs b/crates/openshell-core/src/oauth.rs index c68ecfa6b4..25eff49d4c 100644 --- a/crates/openshell-core/src/oauth.rs +++ b/crates/openshell-core/src/oauth.rs @@ -28,6 +28,15 @@ pub struct OAuthTokenResponse { pub token_type: String, } +/// `OAuth2` refresh-token response. +#[derive(Debug, Clone)] +pub struct OAuthRefreshTokenResponse { + pub access_token: String, + pub refresh_token: Option, + pub expires_in: i64, + pub token_type: String, +} + #[derive(Debug, Deserialize)] struct RawTokenResponse { access_token: String, @@ -35,6 +44,8 @@ struct RawTokenResponse { expires_in: i64, #[serde(default)] token_type: String, + #[serde(default)] + refresh_token: Option, } #[derive(Debug, Deserialize)] @@ -169,6 +180,65 @@ pub async fn post_oauth_token_exchange( .await } +/// Refresh-token grant form fields. +pub struct RefreshTokenParams<'a> { + pub refresh_token: &'a str, + pub client_id: &'a str, + pub scopes: &'a [String], + pub allow_insecure_http: bool, +} + +/// POST an `OAuth2` refresh-token request to a token endpoint. +pub async fn post_oauth_refresh_token( + client: &reqwest::Client, + token_endpoint: &str, + params: &RefreshTokenParams<'_>, +) -> Result { + let token_endpoint_url = + parse_token_endpoint_url_with_policy(token_endpoint, params.allow_insecure_http)?; + let mut form_params = vec![ + ("grant_type", "refresh_token"), + ("refresh_token", params.refresh_token), + ("client_id", params.client_id), + ]; + + let scope_param; + if !params.scopes.is_empty() { + scope_param = params.scopes.join(" "); + form_params.push(("scope", &scope_param)); + } + + let response = client + .post(token_endpoint_url) + .form(&form_params) + .send() + .await + .into_diagnostic() + .wrap_err_with(|| format!("failed to POST to token endpoint {token_endpoint}"))?; + + if !response.status().is_success() { + let status = response.status(); + let body = response + .text() + .await + .unwrap_or_else(|_| "".to_string()); + return Err(miette::miette!("{}", failure_message(status, &body))); + } + + let raw = response + .json::() + .await + .into_diagnostic() + .wrap_err("failed to parse token response as JSON")?; + validate_access_token(&raw.access_token)?; + Ok(OAuthRefreshTokenResponse { + access_token: raw.access_token, + refresh_token: raw.refresh_token, + expires_in: raw.expires_in, + token_type: raw.token_type, + }) +} + pub fn effective_client_assertion_type(client_assertion_type: &str) -> &str { if client_assertion_type.trim().is_empty() { DEFAULT_CLIENT_ASSERTION_TYPE @@ -186,9 +256,19 @@ pub fn effective_token_type(token_type: &str) -> &str { } fn parse_token_endpoint_url(token_endpoint: &str) -> Result { + parse_token_endpoint_url_with_policy(token_endpoint, false) +} + +fn parse_token_endpoint_url_with_policy( + token_endpoint: &str, + allow_insecure_http: bool, +) -> Result { let url = reqwest::Url::parse(token_endpoint) .into_diagnostic() .wrap_err("token_endpoint must be an absolute URL")?; + if allow_insecure_http && matches!(url.scheme(), "http" | "https") { + return Ok(url); + } if token_endpoint_transport_allowed(&url) { return Ok(url); } @@ -698,6 +778,20 @@ mod tests { } } + #[test] + fn token_endpoint_url_can_explicitly_allow_plain_http_for_refresh() { + parse_token_endpoint_url("http://auth.example.com/token") + .expect_err("strict validation should reject arbitrary plain HTTP"); + + parse_token_endpoint_url_with_policy("http://auth.example.com/token", true) + .expect("explicit insecure refresh policy should allow HTTP"); + parse_token_endpoint_url_with_policy("https://auth.example.com/token", true) + .expect("explicit insecure refresh policy should allow HTTPS"); + + parse_token_endpoint_url_with_policy("ftp://auth.example.com/token", true) + .expect_err("non-HTTP token endpoints must still be rejected"); + } + #[test] fn validate_access_token_accepts_token68_values() { for token in [ diff --git a/crates/openshell-gateway-interceptors/src/proto_json.rs b/crates/openshell-gateway-interceptors/src/proto_json.rs index b0d6b0f53d..5eb3c49231 100644 --- a/crates/openshell-gateway-interceptors/src/proto_json.rs +++ b/crates/openshell-gateway-interceptors/src/proto_json.rs @@ -317,6 +317,7 @@ mod tests { annotations: HashMap::new(), workspace: String::new(), await_main_process_attachment: false, + delegated_identity: None, }; let bytes = request.encode_to_vec(); let json = codec diff --git a/crates/openshell-gateway-interceptors/src/runtime.rs b/crates/openshell-gateway-interceptors/src/runtime.rs index 02afddab75..04fc270e14 100644 --- a/crates/openshell-gateway-interceptors/src/runtime.rs +++ b/crates/openshell-gateway-interceptors/src/runtime.rs @@ -1076,6 +1076,7 @@ mod tests { annotations: HashMap::new(), workspace: String::new(), await_main_process_attachment: false, + delegated_identity: None, }; let bytes = request.encode_to_vec(); diff --git a/crates/openshell-providers/src/profiles.rs b/crates/openshell-providers/src/profiles.rs index 6e87826c4d..c464cbc9d5 100644 --- a/crates/openshell-providers/src/profiles.rs +++ b/crates/openshell-providers/src/profiles.rs @@ -2489,31 +2489,43 @@ fn validate_token_grant_subject_token( return diagnostics; }; - let source_value = subject_token.source.trim(); - if source_value != "provider_credential" { - diagnostics.push(ProfileValidationDiagnostic::error( - source, - profile_id, - "credentials.token_grant.subject_token.source", - "subject_token.source must be provider_credential", - )); - } - let subject_credential = subject_token.credential.trim(); - if subject_credential.is_empty() { - diagnostics.push(ProfileValidationDiagnostic::error( - source, - profile_id, - "credentials.token_grant.subject_token.credential", - "subject_token.credential is required", - )); - } else if !credential_names.contains(subject_credential) { - diagnostics.push(ProfileValidationDiagnostic::error( - source, - profile_id, - "credentials.token_grant.subject_token.credential", - format!("unknown subject token credential: {subject_credential}"), - )); + match subject_token.source.trim() { + "provider_credential" => { + if subject_credential.is_empty() { + diagnostics.push(ProfileValidationDiagnostic::error( + source, + profile_id, + "credentials.token_grant.subject_token.credential", + "subject_token.credential is required", + )); + } else if !credential_names.contains(subject_credential) { + diagnostics.push(ProfileValidationDiagnostic::error( + source, + profile_id, + "credentials.token_grant.subject_token.credential", + format!("unknown subject token credential: {subject_credential}"), + )); + } + } + "sandbox_delegated_identity" => { + if !subject_credential.is_empty() { + diagnostics.push(ProfileValidationDiagnostic::error( + source, + profile_id, + "credentials.token_grant.subject_token.credential", + "sandbox_delegated_identity subject_token must not set credential", + )); + } + } + _ => { + diagnostics.push(ProfileValidationDiagnostic::error( + source, + profile_id, + "credentials.token_grant.subject_token.source", + "subject_token.source must be provider_credential or sandbox_delegated_identity", + )); + } } } ProviderCredentialTokenGrantType::Unspecified => { diff --git a/crates/openshell-sdk/src/client.rs b/crates/openshell-sdk/src/client.rs index fd2b7d5273..872e2a7d68 100644 --- a/crates/openshell-sdk/src/client.rs +++ b/crates/openshell-sdk/src/client.rs @@ -835,6 +835,7 @@ fn create_sandbox_request(spec: SandboxSpec) -> proto::CreateSandboxRequest { annotations: HashMap::new(), workspace: String::new(), await_main_process_attachment: false, + delegated_identity: None, } } diff --git a/crates/openshell-sdk/tests/client_mock.rs b/crates/openshell-sdk/tests/client_mock.rs index 1cdac7da41..2bde7083db 100644 --- a/crates/openshell-sdk/tests/client_mock.rs +++ b/crates/openshell-sdk/tests/client_mock.rs @@ -209,6 +209,55 @@ impl OpenShell for TestOpenShell { })) } + async fn get_sandbox_delegated_identity_status( + &self, + _request: tonic::Request, + ) -> Result, Status> { + Err(Status::unimplemented("unused")) + } + + async fn withdraw_sandbox_delegated_identity( + &self, + _request: tonic::Request, + ) -> Result, Status> { + Err(Status::unimplemented("unused")) + } + + async fn extend_sandbox_delegated_identity( + &self, + _request: tonic::Request, + ) -> Result, Status> { + Err(Status::unimplemented("unused")) + } + + async fn list_delegated_identity_credentials( + &self, + _request: tonic::Request, + ) -> Result, Status> { + Err(Status::unimplemented("unused")) + } + + async fn get_delegated_identity_credential_status( + &self, + _request: tonic::Request, + ) -> Result, Status> { + Err(Status::unimplemented("unused")) + } + + async fn revoke_delegated_identity_credential( + &self, + _request: tonic::Request, + ) -> Result, Status> { + Err(Status::unimplemented("unused")) + } + + async fn delete_delegated_identity_credential( + &self, + _request: tonic::Request, + ) -> Result, Status> { + Err(Status::unimplemented("unused")) + } + async fn get_sandbox( &self, request: tonic::Request, diff --git a/crates/openshell-server/src/auth/oidc.rs b/crates/openshell-server/src/auth/oidc.rs index 475c52ebec..ba99edc715 100644 --- a/crates/openshell-server/src/auth/oidc.rs +++ b/crates/openshell-server/src/auth/oidc.rs @@ -95,6 +95,8 @@ struct JwkKey { pub struct OidcClaims { pub sub: String, #[serde(default)] + pub exp: i64, + #[serde(default)] pub preferred_username: Option, #[serde(default)] #[allow(dead_code)] @@ -287,6 +289,11 @@ impl JwksCache { /// This is the authentication step — it verifies the caller's identity /// but does not check authorization (that's `authz::AuthzPolicy::check`). pub async fn validate_token(&self, token: &str) -> Result { + Ok(self.validate_token_details(token).await?.identity) + } + + /// Validate a JWT and return the derived identity plus verified token metadata. + pub async fn validate_token_details(&self, token: &str) -> Result { crate::install_jsonwebtoken_crypto_provider(); self.refresh_if_stale().await.map_err(|e| { @@ -334,6 +341,10 @@ impl JwksCache { })?; let mut claims = token_data.claims; + let expires_at_ms = claims.exp.saturating_mul(1000); + if expires_at_ms <= 0 { + return Err(Status::unauthenticated("invalid token: invalid exp")); + } claims.extract_roles(&self.config.roles_claim); let scopes = if self.config.scopes_claim.is_empty() { @@ -342,16 +353,25 @@ impl JwksCache { claims.extract_scopes(&self.config.scopes_claim) }; - Ok(Identity { - subject: claims.sub, - display_name: claims.preferred_username, - roles: claims.roles, - scopes, - provider: IdentityProvider::Oidc, + Ok(ValidatedOidcToken { + identity: Identity { + subject: claims.sub, + display_name: claims.preferred_username, + roles: claims.roles, + scopes, + provider: IdentityProvider::Oidc, + }, + expires_at_ms, }) } } +/// A verified OIDC access token and server-derived metadata. +pub struct ValidatedOidcToken { + pub identity: Identity, + pub expires_at_ms: i64, +} + /// Authenticator that validates `Authorization: Bearer ` headers against /// the configured OIDC issuer. /// diff --git a/crates/openshell-server/src/cli.rs b/crates/openshell-server/src/cli.rs index f22e1355e4..81b4afadaf 100644 --- a/crates/openshell-server/src/cli.rs +++ b/crates/openshell-server/src/cli.rs @@ -456,6 +456,13 @@ fn prepare_server_config( config = config.with_ssh_session_ttl_secs(ttl); } + if let Some(max_secs) = file + .as_ref() + .and_then(|f| f.openshell.gateway.max_delegated_identity_duration_secs) + { + config = config.with_max_delegated_identity_duration_secs(max_secs); + } + if let Some(mode) = file .as_ref() .and_then(|f| f.openshell.gateway.policy_validation_failure_mode) diff --git a/crates/openshell-server/src/compute/mod.rs b/crates/openshell-server/src/compute/mod.rs index ef311523a9..65a73ad917 100644 --- a/crates/openshell-server/src/compute/mod.rs +++ b/crates/openshell-server/src/compute/mod.rs @@ -47,8 +47,8 @@ use openshell_core::proto::compute::v1::{ gateway_listener_requirement::Selector, watch_sandboxes_event, }; use openshell_core::proto::{ - PlatformEvent, Sandbox, SandboxCondition, SandboxPhase, SandboxSpec, SandboxStatus, - SandboxTemplate, ServiceEndpoint, SshSession, + PlatformEvent, Sandbox, SandboxCondition, SandboxDelegatedIdentityRecord, SandboxPhase, + SandboxSpec, SandboxStatus, SandboxTemplate, ServiceEndpoint, SshSession, }; use openshell_core::{ObjectLabels, ObjectWorkspace}; #[cfg(all(not(target_os = "windows"), feature = "in-tree-compute-drivers"))] @@ -3156,6 +3156,15 @@ impl ComputeRuntime { .await?; self.cleanup_sandbox_service_endpoints(sandbox.object_id(), sandbox.object_workspace()) .await?; + self.store + .delete( + SandboxDelegatedIdentityRecord::object_type(), + &crate::delegated_identity::sandbox_delegated_identity_record_id( + sandbox.object_id(), + ), + ) + .await + .map_err(|e| format!("delete sandbox delegated identity: {e}"))?; self.store .delete_by_name( diff --git a/crates/openshell-server/src/config_file.rs b/crates/openshell-server/src/config_file.rs index 74b6aad01b..fd0fceb6d2 100644 --- a/crates/openshell-server/src/config_file.rs +++ b/crates/openshell-server/src/config_file.rs @@ -120,6 +120,8 @@ pub struct GatewayFileSection { #[serde(default)] pub ssh_session_ttl_secs: Option, #[serde(default)] + pub max_delegated_identity_duration_secs: Option, + #[serde(default)] pub grpc_rate_limit_requests: Option, #[serde(default)] pub grpc_rate_limit_window_seconds: Option, diff --git a/crates/openshell-server/src/delegated_identity.rs b/crates/openshell-server/src/delegated_identity.rs new file mode 100644 index 0000000000..916600cf00 --- /dev/null +++ b/crates/openshell-server/src/delegated_identity.rs @@ -0,0 +1,1639 @@ +// SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +//! Gateway-scoped delegated OIDC identity credentials for sandbox token exchange. + +use crate::ServerState; +use crate::auth::principal::{Principal, UserPrincipal}; +use crate::auth::workspace_authz::{MinWorkspaceRole, authorize_workspace, require_platform_admin}; +use crate::persistence::{ObjectType, WriteCondition, current_time_ms}; +use openshell_core::proto::datamodel::v1::ObjectMeta; +use openshell_core::proto::{ + DelegatedIdentityCredential, DelegatedIdentityCredentialSummary, DelegatedIdentityRequest, + DeleteDelegatedIdentityCredentialRequest, DeleteDelegatedIdentityCredentialResponse, + ExtendSandboxDelegatedIdentityRequest, ExtendSandboxDelegatedIdentityResponse, + GetDelegatedIdentityCredentialStatusRequest, GetDelegatedIdentityCredentialStatusResponse, + GetSandboxDelegatedIdentityStatusRequest, GetSandboxDelegatedIdentityStatusResponse, + ListDelegatedIdentityCredentialsRequest, ListDelegatedIdentityCredentialsResponse, + RevokeDelegatedIdentityCredentialRequest, RevokeDelegatedIdentityCredentialResponse, Sandbox, + SandboxDelegatedIdentity, SandboxDelegatedIdentityRecord, + WithdrawSandboxDelegatedIdentityRequest, WithdrawSandboxDelegatedIdentityResponse, +}; +use openshell_core::{GetResourceVersion, ObjectId, ObjectLabels, ObjectName, ObjectWorkspace}; +use prost::Message; +use serde::Deserialize; +use sha2::{Digest, Sha256}; +use std::collections::HashMap; +use std::sync::{Arc, LazyLock}; +use std::time::Duration; +use tonic::{Request, Response, Status}; + +const CREDENTIAL_OBJECT_TYPE: &str = "delegated_identity_credential"; +const SANDBOX_DELEGATION_OBJECT_TYPE: &str = "sandbox_delegated_identity"; +const GLOBAL_WORKSPACE: &str = ""; +const REFRESH_SKEW_MS: i64 = 60_000; +static DELEGATED_IDENTITY_HTTP_CLIENT: LazyLock> = + LazyLock::new(|| { + reqwest::Client::builder() + .timeout(Duration::from_secs(30)) + .connect_timeout(Duration::from_secs(30)) + .build() + .map_err(|err| format!("delegated identity HTTP client configuration failed: {err}")) + }); + +pub struct PreparedSandboxDelegatedIdentity { + pub record: SandboxDelegatedIdentityRecord, + credential_id: String, + credential_resource_version: u64, + credential_created: bool, +} + +impl ObjectType for DelegatedIdentityCredential { + fn object_type() -> &'static str { + CREDENTIAL_OBJECT_TYPE + } +} + +impl ObjectType for SandboxDelegatedIdentityRecord { + fn object_type() -> &'static str { + SANDBOX_DELEGATION_OBJECT_TYPE + } +} + +pub async fn prepare_for_sandbox_create( + state: &Arc, + principal: &Principal, + sandbox: &Sandbox, + request: Option, +) -> Result, Status> { + let Some(request) = request else { + return Ok(None); + }; + let user = require_user(principal)?; + let access_token_expires_at_ms = validate_delegation_request(state, user, &request).await?; + let credential = + upsert_credential(state, user, request.clone(), access_token_expires_at_ms).await?; + let credential_id = credential.credential.object_id().to_string(); + let credential_resource_version = credential.credential.get_resource_version(); + let sandbox_id = sandbox.object_id().to_string(); + let record_id = sandbox_delegated_identity_record_id(&sandbox_id); + Ok(Some(PreparedSandboxDelegatedIdentity { + record: SandboxDelegatedIdentityRecord { + metadata: Some(ObjectMeta { + id: record_id.clone(), + name: record_id, + created_at_ms: current_time_ms(), + labels: HashMap::new(), + resource_version: 0, + annotations: HashMap::new(), + workspace: sandbox.object_workspace().to_string(), + deletion_timestamp_ms: 0, + }), + sandbox_id, + delegated_identity: Some(SandboxDelegatedIdentity { + credential_id: credential_id.clone(), + principal_subject: user.identity.subject.clone(), + delegated_until_ms: request.delegated_until_ms, + withdrawn_at_ms: 0, + }), + }, + credential_id, + credential_resource_version, + credential_created: credential.created, + })) +} + +pub async fn store_prepared_sandbox_delegation( + state: &Arc, + prepared: Option<&PreparedSandboxDelegatedIdentity>, +) -> Result<(), Status> { + let Some(prepared) = prepared else { + return Ok(()); + }; + state + .store + .put_scoped_message(&prepared.record, &prepared.record.sandbox_id) + .await + .map_err(|e| Status::internal(format!("persist sandbox delegated identity failed: {e}"))) +} + +pub async fn delete_prepared_sandbox_delegation( + state: &Arc, + prepared: Option<&PreparedSandboxDelegatedIdentity>, +) -> Result<(), Status> { + let Some(prepared) = prepared else { + return Ok(()); + }; + state + .store + .delete( + SandboxDelegatedIdentityRecord::object_type(), + prepared.record.object_id(), + ) + .await + .map(|_| ()) + .map_err(|e| Status::internal(format!("delete sandbox delegated identity failed: {e}"))) +} + +pub async fn delete_new_prepared_sandbox_credential( + state: &Arc, + prepared: Option<&PreparedSandboxDelegatedIdentity>, +) -> Result<(), Status> { + let Some(prepared) = prepared.filter(|prepared| prepared.credential_created) else { + return Ok(()); + }; + state + .store + .delete_if( + DelegatedIdentityCredential::object_type(), + &prepared.credential_id, + prepared.credential_resource_version, + ) + .await + .map(|_| ()) + .map_err(|e| Status::internal(format!("delete prepared delegated credential failed: {e}"))) +} + +pub async fn resolve_subject_access_token( + state: &Arc, + sandbox: &Sandbox, +) -> Result<(String, i64, String), Status> { + let record = sandbox_delegated_identity_record(state, sandbox).await?; + let delegation = record + .as_ref() + .and_then(|record| record.delegated_identity.as_ref()) + .ok_or_else(|| { + Status::failed_precondition("sandbox was not created with delegated identity") + })?; + if delegation.withdrawn_at_ms > 0 { + return Err(Status::failed_precondition("delegated identity withdrawn")); + } + let now = current_time_ms(); + if delegation.delegated_until_ms <= now { + return Err(Status::failed_precondition("delegated identity expired")); + } + let credential = state + .store + .get_message::(&delegation.credential_id) + .await + .map_err(|e| Status::internal(format!("fetch delegated credential failed: {e}")))? + .ok_or_else(|| Status::failed_precondition("delegated credential missing"))?; + if credential.principal_subject != delegation.principal_subject { + return Err(Status::failed_precondition( + "delegated credential principal does not match sandbox delegation", + )); + } + if credential.revoked_at_ms > 0 { + return Err(Status::failed_precondition("delegated credential revoked")); + } + let credential = refresh_if_needed(state, credential).await?; + let credential_id = credential.object_id().to_string(); + Ok(( + credential.access_token, + credential.access_token_expires_at_ms, + credential_id, + )) +} + +pub async fn handle_status( + state: &Arc, + request: Request, +) -> Result, Status> { + let principal = crate::grpc::extract_principal(&request)?; + let req = request.into_inner(); + let sandbox = authorized_sandbox_by_name(state, &principal, &req.workspace, &req.name).await?; + let record = sandbox_delegated_identity_record(state, &sandbox).await?; + let delegation = record + .as_ref() + .and_then(|record| record.delegated_identity.as_ref()); + if delegation.is_some() { + ensure_delegator(&principal, delegation)?; + } + let (credential_revoked_at_ms, credential_missing) = + sandbox_delegated_identity_credential_status(state, delegation).await?; + Ok(Response::new(GetSandboxDelegatedIdentityStatusResponse { + delegated_identity: delegation.cloned(), + now_ms: current_time_ms(), + credential_revoked_at_ms, + credential_missing, + })) +} + +async fn sandbox_delegated_identity_credential_status( + state: &Arc, + delegation: Option<&SandboxDelegatedIdentity>, +) -> Result<(i64, bool), Status> { + let Some(delegation) = delegation else { + return Ok((0, true)); + }; + let credential = state + .store + .get_message::(&delegation.credential_id) + .await + .map_err(|e| Status::internal(format!("fetch delegated credential failed: {e}")))?; + Ok(delegated_credential_status_fields(credential.as_ref())) +} + +fn delegated_credential_status_fields( + credential: Option<&DelegatedIdentityCredential>, +) -> (i64, bool) { + credential.map_or((0, true), |credential| (credential.revoked_at_ms, false)) +} + +async fn sandbox_delegated_identity_record( + state: &Arc, + sandbox: &Sandbox, +) -> Result, Status> { + state + .store + .get_message::(&sandbox_delegated_identity_record_id( + sandbox.object_id(), + )) + .await + .map_err(|e| Status::internal(format!("fetch sandbox delegated identity failed: {e}"))) +} + +pub fn sandbox_delegated_identity_record_id(sandbox_id: &str) -> String { + format!("sandbox-delegated-identity-{sandbox_id}") +} + +pub async fn ensure_delegated_identity_sandbox_user( + state: &Arc, + principal: &Principal, + sandbox: &Sandbox, +) -> Result<(), Status> { + let record = sandbox_delegated_identity_record(state, sandbox).await?; + let Some(delegation) = record + .as_ref() + .and_then(|record| record.delegated_identity.as_ref()) + else { + return Ok(()); + }; + + match principal { + Principal::User(user) if user.identity.subject == delegation.principal_subject => Ok(()), + Principal::User(_) => Err(Status::permission_denied( + "delegated identity sandbox access denied: caller is not the delegating principal", + )), + Principal::Sandbox(_) => Ok(()), + Principal::Anonymous => Err(Status::unauthenticated( + "sandbox-scoped methods require an authenticated caller", + )), + } +} + +pub async fn handle_withdraw( + state: &Arc, + request: Request, +) -> Result, Status> { + let principal = crate::grpc::extract_principal(&request)?; + let req = request.into_inner(); + let sandbox = authorized_sandbox_by_name(state, &principal, &req.workspace, &req.name).await?; + let record = sandbox_delegated_identity_record(state, &sandbox).await?; + let delegation = record + .as_ref() + .and_then(|record| record.delegated_identity.as_ref()); + ensure_delegator(&principal, delegation)?; + let Some(record) = record else { + return Err(Status::invalid_argument( + "sandbox delegated identity is not enabled", + )); + }; + let now = current_time_ms(); + let mut changed = false; + state + .store + .update_message_cas::(record.object_id(), 0, |current| { + if let Some(delegation) = current.delegated_identity.as_mut() + && delegation.withdrawn_at_ms == 0 + { + delegation.withdrawn_at_ms = now; + changed = true; + } + }) + .await + .map_err(|e| crate::grpc::persistence_error_to_status(e, "withdraw delegated identity"))?; + Ok(Response::new(WithdrawSandboxDelegatedIdentityResponse { + sandbox: Some(sandbox), + withdrawn: changed, + })) +} + +pub async fn handle_extend( + state: &Arc, + request: Request, +) -> Result, Status> { + let principal = crate::grpc::extract_principal(&request)?; + let req = request.into_inner(); + let material = req + .delegated_identity + .ok_or_else(|| Status::invalid_argument("delegated_identity is required"))?; + let sandbox = authorized_sandbox_by_name(state, &principal, &req.workspace, &req.name).await?; + let record = sandbox_delegated_identity_record(state, &sandbox).await?; + let delegation = record + .as_ref() + .and_then(|record| record.delegated_identity.as_ref()); + ensure_delegator(&principal, delegation)?; + let Some(record) = record else { + return Err(Status::invalid_argument( + "sandbox delegated identity is not enabled", + )); + }; + let user = require_user(&principal)?; + let access_token_expires_at_ms = validate_delegation_request(state, user, &material).await?; + let credential = + upsert_credential(state, user, material.clone(), access_token_expires_at_ms).await?; + let update_result = state + .store + .update_message_cas::(record.object_id(), 0, |current| { + if let Some(delegation) = current.delegated_identity.as_mut() { + delegation.credential_id = credential.credential.object_id().to_string(); + delegation.delegated_until_ms = material.delegated_until_ms; + delegation.withdrawn_at_ms = 0; + } + }) + .await; + if let Err(error) = update_result { + cleanup_new_credential_after_prepare_failure(state, &credential).await?; + return Err(crate::grpc::persistence_error_to_status( + error, + "extend delegated identity", + )); + } + Ok(Response::new(ExtendSandboxDelegatedIdentityResponse { + sandbox: Some(sandbox), + })) +} + +pub async fn handle_list_credentials( + state: &Arc, + request: Request, +) -> Result, Status> { + let principal = crate::grpc::extract_principal(&request)?; + require_platform_admin(&state.admin_role, &principal)?; + let req = request.into_inner(); + let credentials = state + .store + .list_all_messages::( + crate::grpc::clamp_limit(req.limit, 100, crate::grpc::MAX_PAGE_SIZE), + req.offset, + ) + .await + .map_err(|e| Status::internal(format!("list delegated credentials failed: {e}")))?; + let credentials = credentials + .into_iter() + .map(delegated_credential_summary) + .collect(); + Ok(Response::new(ListDelegatedIdentityCredentialsResponse { + credentials, + })) +} + +pub async fn handle_get_credential_status( + state: &Arc, + request: Request, +) -> Result, Status> { + let principal = crate::grpc::extract_principal(&request)?; + require_platform_admin(&state.admin_role, &principal)?; + let req = request.into_inner(); + let credential = state + .store + .get_message::(&req.id) + .await + .map_err(|e| Status::internal(format!("fetch delegated credential failed: {e}")))? + .ok_or_else(|| Status::not_found("delegated credential not found"))?; + Ok(Response::new( + GetDelegatedIdentityCredentialStatusResponse { + credential: Some(delegated_credential_summary(credential)), + now_ms: current_time_ms(), + }, + )) +} + +fn delegated_credential_summary( + credential: DelegatedIdentityCredential, +) -> DelegatedIdentityCredentialSummary { + DelegatedIdentityCredentialSummary { + metadata: credential.metadata, + issuer: credential.issuer, + client_id: credential.client_id, + principal_subject: credential.principal_subject, + refresh_token_present: !credential.refresh_token.is_empty(), + access_token_present: !credential.access_token.is_empty(), + access_token_expires_at_ms: credential.access_token_expires_at_ms, + scopes: credential.scopes, + audience: credential.audience, + last_refresh_at_ms: credential.last_refresh_at_ms, + revoked_at_ms: credential.revoked_at_ms, + } +} + +pub async fn handle_revoke_credential( + state: &Arc, + request: Request, +) -> Result, Status> { + let principal = crate::grpc::extract_principal(&request)?; + require_platform_admin(&state.admin_role, &principal)?; + let req = request.into_inner(); + let now = current_time_ms(); + let mut revoked = false; + let credential = state + .store + .update_message_cas::( + &req.id, + req.expected_resource_version, + |credential| { + if credential.revoked_at_ms == 0 { + credential.revoked_at_ms = now; + revoked = true; + } + }, + ) + .await + .map_err(|e| crate::grpc::persistence_error_to_status(e, "revoke delegated credential"))?; + let resource_version = credential + .metadata + .as_ref() + .map(|metadata| metadata.resource_version) + .unwrap_or_default(); + Ok(Response::new(RevokeDelegatedIdentityCredentialResponse { + revoked, + revoked_at_ms: credential.revoked_at_ms, + resource_version, + })) +} + +pub async fn handle_delete_credential( + state: &Arc, + request: Request, +) -> Result, Status> { + let principal = crate::grpc::extract_principal(&request)?; + require_platform_admin(&state.admin_role, &principal)?; + let req = request.into_inner(); + let expected_resource_version = + delete_credential_resource_version(state, &req.id, req.expected_resource_version).await?; + let Some(expected_resource_version) = expected_resource_version else { + return Ok(Response::new(DeleteDelegatedIdentityCredentialResponse { + deleted: false, + })); + }; + let deleted = state + .store + .delete_if( + DelegatedIdentityCredential::object_type(), + &req.id, + expected_resource_version, + ) + .await + .map_err(|e| crate::grpc::persistence_error_to_status(e, "delete delegated credential"))?; + Ok(Response::new(DeleteDelegatedIdentityCredentialResponse { + deleted, + })) +} + +async fn delete_credential_resource_version( + state: &Arc, + id: &str, + expected_resource_version: u64, +) -> Result, Status> { + if expected_resource_version != 0 { + return Ok(Some(expected_resource_version)); + } + let credential = state + .store + .get_message::(id) + .await + .map_err(|e| Status::internal(format!("fetch delegated credential failed: {e}")))?; + Ok(effective_delete_credential_resource_version( + credential.as_ref(), + expected_resource_version, + )) +} + +fn effective_delete_credential_resource_version( + credential: Option<&DelegatedIdentityCredential>, + expected_resource_version: u64, +) -> Option { + if expected_resource_version != 0 { + Some(expected_resource_version) + } else { + credential + .and_then(|credential| credential.metadata.as_ref()) + .map(|metadata| metadata.resource_version) + } +} + +fn require_user(principal: &Principal) -> Result<&UserPrincipal, Status> { + match principal { + Principal::User(user) => Ok(user), + _ => Err(Status::permission_denied( + "delegated identity requires an authenticated user principal", + )), + } +} + +fn ensure_delegator( + principal: &Principal, + delegation: Option<&SandboxDelegatedIdentity>, +) -> Result<(), Status> { + let user = require_user(principal)?; + let delegation = delegation.ok_or_else(|| { + Status::failed_precondition("sandbox was not created with delegated identity") + })?; + if delegation.principal_subject != user.identity.subject { + return Err(Status::permission_denied( + "only the delegating principal may manage this sandbox delegated identity", + )); + } + Ok(()) +} + +async fn validate_delegation_request( + state: &Arc, + user: &UserPrincipal, + request: &DelegatedIdentityRequest, +) -> Result { + if request.issuer.trim().is_empty() { + return Err(Status::invalid_argument( + "delegated_identity.issuer is required", + )); + } + let configured_issuer = state + .config + .oidc + .as_ref() + .map(|oidc| oidc.issuer.trim_end_matches('/')) + .ok_or_else(|| { + Status::failed_precondition( + "delegated identity requires gateway OIDC authentication to be configured", + ) + })?; + if request.issuer.trim_end_matches('/') != configured_issuer { + return Err(Status::invalid_argument( + "delegated_identity.issuer must match the gateway OIDC issuer", + )); + } + if request.client_id.trim().is_empty() { + return Err(Status::invalid_argument( + "delegated_identity.client_id is required", + )); + } + if request.refresh_token.trim().is_empty() { + return Err(Status::invalid_argument( + "delegated_identity.refresh_token is required", + )); + } + if request.access_token.trim().is_empty() { + return Err(Status::invalid_argument( + "delegated_identity.access_token is required", + )); + } + let access_token_expires_at_ms = + validate_delegated_access_token_subject(state, user, request).await?; + let now = current_time_ms(); + if request.delegated_until_ms <= now { + return Err(Status::invalid_argument( + "delegated_identity.delegated_until_ms must be in the future", + )); + } + let max_ms = i64::try_from(state.config.max_delegated_identity_duration_secs) + .unwrap_or(i64::MAX / 1000) + .saturating_mul(1000); + if request.delegated_until_ms.saturating_sub(now) > max_ms { + return Err(Status::failed_precondition(format!( + "delegated identity duration exceeds gateway maximum of {} seconds", + state.config.max_delegated_identity_duration_secs + ))); + } + Ok(access_token_expires_at_ms) +} + +async fn validate_delegated_access_token_subject( + state: &Arc, + user: &UserPrincipal, + request: &DelegatedIdentityRequest, +) -> Result { + validate_delegated_access_token_subject_value( + state, + &request.access_token, + &user.identity.subject, + ) + .await +} + +async fn validate_delegated_access_token_subject_value( + state: &Arc, + access_token: &str, + expected_subject: &str, +) -> Result { + let cache = state.oidc_cache.as_ref().ok_or_else(|| { + Status::failed_precondition( + "delegated identity requires gateway OIDC token validation to be configured", + ) + })?; + let validated = cache.validate_token_details(access_token).await?; + ensure_delegated_token_subject_matches(&validated.identity.subject, expected_subject)?; + Ok(validated.expires_at_ms) +} + +fn ensure_delegated_token_subject_matches( + token_subject: &str, + caller_subject: &str, +) -> Result<(), Status> { + if token_subject == caller_subject { + Ok(()) + } else { + Err(Status::permission_denied( + "delegated_identity.access_token subject must match the authenticated caller", + )) + } +} + +async fn authorized_sandbox_by_name( + state: &Arc, + principal: &Principal, + workspace: &str, + name: &str, +) -> Result { + if name.trim().is_empty() { + return Err(Status::invalid_argument("name is required")); + } + let authz = authorize_workspace( + &state.store, + &state.admin_role, + principal, + workspace, + MinWorkspaceRole::User, + ) + .await?; + let workspace = + crate::grpc::workspace::resolve_workspace(state.store.as_ref(), &authz.workspace) + .await? + .name; + state + .store + .get_message_by_name::(&workspace, name) + .await + .map_err(|e| Status::internal(format!("fetch sandbox failed: {e}")))? + .ok_or_else(|| Status::not_found("sandbox not found")) +} + +async fn upsert_credential( + state: &Arc, + user: &UserPrincipal, + request: DelegatedIdentityRequest, + access_token_expires_at_ms: i64, +) -> Result { + let id = delegated_credential_id(&request.issuer, &request.client_id, &user.identity.subject); + let now = current_time_ms(); + let mut credential = DelegatedIdentityCredential { + metadata: Some(ObjectMeta { + id: id.clone(), + name: id.clone(), + created_at_ms: now, + labels: HashMap::new(), + resource_version: 0, + annotations: HashMap::new(), + workspace: GLOBAL_WORKSPACE.to_string(), + deletion_timestamp_ms: 0, + }), + issuer: request.issuer, + client_id: request.client_id, + principal_subject: user.identity.subject.clone(), + refresh_token: request.refresh_token, + access_token: request.access_token, + access_token_expires_at_ms, + scopes: request.scopes, + audience: request.audience, + last_refresh_at_ms: now, + revoked_at_ms: 0, + }; + + let existing = state + .store + .get_message::(&id) + .await + .map_err(|e| Status::internal(format!("fetch delegated credential failed: {e}")))?; + let (created, write_condition) = if let Some(existing) = existing { + ensure_delegated_credential_not_revoked(&existing)?; + let write_condition = delegated_credential_upsert_condition(&existing); + credential.metadata = existing.metadata; + credential.revoked_at_ms = existing.revoked_at_ms; + (false, write_condition) + } else { + (true, WriteCondition::MustCreate) + }; + let labels = credential + .object_labels() + .filter(|labels| !labels.is_empty()) + .map(|labels| { + serde_json::to_string(&labels) + .map_err(|e| Status::internal(format!("serialize labels failed: {e}"))) + }) + .transpose()?; + let result = state + .store + .put_if( + DelegatedIdentityCredential::object_type(), + credential.object_id(), + credential.object_name(), + credential.object_workspace(), + &credential.encode_to_vec(), + labels.as_deref(), + write_condition, + ) + .await + .map_err(|e| crate::grpc::persistence_error_to_status(e, "persist delegated credential"))?; + if let Some(metadata) = credential.metadata.as_mut() { + metadata.resource_version = result.resource_version; + } + Ok(UpsertedCredential { + credential, + created, + }) +} + +fn delegated_credential_upsert_condition(existing: &DelegatedIdentityCredential) -> WriteCondition { + WriteCondition::MatchResourceVersion(existing.get_resource_version()) +} + +struct UpsertedCredential { + credential: DelegatedIdentityCredential, + created: bool, +} + +async fn cleanup_new_credential_after_prepare_failure( + state: &Arc, + credential: &UpsertedCredential, +) -> Result<(), Status> { + if !credential.created { + return Ok(()); + } + state + .store + .delete_if( + DelegatedIdentityCredential::object_type(), + credential.credential.object_id(), + credential.credential.get_resource_version(), + ) + .await + .map(|_| ()) + .map_err(|e| Status::internal(format!("delete prepared delegated credential failed: {e}"))) +} + +fn ensure_delegated_credential_not_revoked( + credential: &DelegatedIdentityCredential, +) -> Result<(), Status> { + if credential.revoked_at_ms > 0 { + Err(Status::failed_precondition( + "delegated identity credential is revoked", + )) + } else { + Ok(()) + } +} + +fn delegated_credential_id(issuer: &str, client_id: &str, principal_subject: &str) -> String { + let mut hasher = Sha256::new(); + hasher.update(issuer.trim_end_matches('/')); + hasher.update(b"\0"); + hasher.update(client_id); + hasher.update(b"\0"); + hasher.update(principal_subject); + format!("delegated-identity-{:x}", hasher.finalize()) +} + +async fn refresh_if_needed( + state: &Arc, + credential: DelegatedIdentityCredential, +) -> Result { + let now = current_time_ms(); + if credential.access_token_expires_at_ms > 0 + && credential.access_token_expires_at_ms.saturating_sub(now) > REFRESH_SKEW_MS + { + return Ok(credential); + } + let client = delegated_identity_http_client()?; + let token_endpoint = discover_token_endpoint(client, &credential.issuer).await?; + let scopes = credential + .scopes + .split_whitespace() + .filter(|scope| !scope.is_empty()) + .map(ToString::to_string) + .collect::>(); + let refreshed = openshell_core::oauth::post_oauth_refresh_token( + client, + &token_endpoint, + &openshell_core::oauth::RefreshTokenParams { + refresh_token: &credential.refresh_token, + client_id: &credential.client_id, + scopes: &scopes, + allow_insecure_http: delegated_refresh_allows_insecure_http( + &credential.issuer, + &token_endpoint, + ), + }, + ) + .await + .map_err(|e| Status::failed_precondition(delegated_refresh_error_message(&e.to_string())))?; + let expires_at_ms = validate_delegated_access_token_subject_value( + state, + &refreshed.access_token, + &credential.principal_subject, + ) + .await?; + let refreshed_refresh_token = refreshed.refresh_token; + let refreshed_access_token = refreshed.access_token; + let updated = state + .store + .update_message_cas::( + credential.object_id(), + credential.get_resource_version(), + |current| { + current.access_token.clone_from(&refreshed_access_token); + current.access_token_expires_at_ms = expires_at_ms; + current.last_refresh_at_ms = now; + if let Some(refresh_token) = refreshed_refresh_token.as_ref() { + current.refresh_token.clone_from(refresh_token); + } + }, + ) + .await + .map_err(|e| crate::grpc::persistence_error_to_status(e, "refresh delegated credential"))?; + Ok(updated) +} + +fn delegated_identity_http_client() -> Result<&'static reqwest::Client, Status> { + DELEGATED_IDENTITY_HTTP_CLIENT + .as_ref() + .map_err(|err| Status::internal(err.clone())) +} + +fn delegated_refresh_allows_insecure_http(issuer: &str, token_endpoint: &str) -> bool { + let Ok(issuer) = reqwest::Url::parse(issuer) else { + return false; + }; + let Ok(token_endpoint) = reqwest::Url::parse(token_endpoint) else { + return false; + }; + issuer.scheme() == "http" + && token_endpoint.scheme() == "http" + && issuer.host_str() == token_endpoint.host_str() + && issuer.port_or_known_default() == token_endpoint.port_or_known_default() +} + +fn delegated_refresh_error_message(error: &str) -> String { + let mut message = format!("delegated credential refresh failed: {error}"); + if inactive_refresh_token_error(error) { + message.push_str( + "; the stored delegated identity refresh token is no longer active. \ + Re-authenticate with `openshell gateway logout` followed by `openshell gateway login`, \ + then run `openshell sandbox delegated-identity extend --for=`.", + ); + } + message +} + +fn inactive_refresh_token_error(error: &str) -> bool { + let error = error.to_ascii_lowercase(); + error.contains("invalid_grant") + && (error.contains("session not active") + || error.contains("session inactive") + || error.contains("refresh token")) +} + +#[derive(Debug, Deserialize)] +struct OidcDiscovery { + issuer: String, + token_endpoint: String, +} + +async fn discover_token_endpoint(client: &reqwest::Client, issuer: &str) -> Result { + let normalized = issuer.trim_end_matches('/'); + let url = format!("{normalized}/.well-known/openid-configuration"); + let discovery = client + .get(url) + .send() + .await + .map_err(|e| Status::failed_precondition(format!("OIDC discovery failed: {e}")))? + .error_for_status() + .map_err(|e| Status::failed_precondition(format!("OIDC discovery failed: {e}")))? + .json::() + .await + .map_err(|e| Status::failed_precondition(format!("OIDC discovery parse failed: {e}")))?; + if discovery.issuer.trim_end_matches('/') != normalized { + return Err(Status::failed_precondition( + "OIDC discovery issuer does not match delegated credential issuer", + )); + } + Ok(discovery.token_endpoint) +} + +#[cfg(test)] +mod tests { + use super::{ + PreparedSandboxDelegatedIdentity, delegated_credential_id, + delegated_credential_status_fields, delegated_credential_summary, + delegated_credential_upsert_condition, delegated_refresh_allows_insecure_http, + delegated_refresh_error_message, delete_new_prepared_sandbox_credential, + effective_delete_credential_resource_version, ensure_delegated_credential_not_revoked, + ensure_delegated_token_subject_matches, sandbox_delegated_identity_record_id, + }; + use crate::grpc::test_support::{authed_request, test_server_state}; + use crate::persistence::{ObjectType, Store, WriteCondition, current_time_ms}; + use crate::sandbox_index::SandboxIndex; + use crate::sandbox_watch::SandboxWatchBus; + use crate::supervisor_session::SupervisorSessionRegistry; + use crate::tracing_bus::TracingLogBus; + use openshell_core::proto::datamodel::v1::ObjectMeta; + use openshell_core::proto::{ + DelegatedIdentityCredential, DelegatedIdentityRequest, + ExtendSandboxDelegatedIdentityRequest, GetSandboxDelegatedIdentityStatusRequest, Sandbox, + SandboxDelegatedIdentity, SandboxDelegatedIdentityRecord, SandboxSpec, SandboxStatus, + }; + use openshell_core::{Config, GetResourceVersion, ObjectId, OidcConfig}; + use prost::Message as _; + use std::collections::HashMap; + use std::sync::{Arc, LazyLock}; + use tonic::Code; + use tonic::Request; + + const TEST_KID: &str = "test-signing-key"; + const TEST_AUDIENCE: &str = "openshell-cli"; + + static TEST_RSA_KEY: LazyLock = LazyLock::new(TestRsaKey::generate); + + struct TestRsaKey { + private_pem: String, + modulus_b64: String, + exponent_b64: String, + } + + impl TestRsaKey { + fn generate() -> Self { + use base64::Engine as _; + use rsa::pkcs1::EncodeRsaPrivateKey as _; + use rsa::traits::PublicKeyParts as _; + + let private = rsa::RsaPrivateKey::new(&mut rsa::rand_core::OsRng, 2048) + .expect("generate RSA test key"); + let b64 = base64::engine::general_purpose::URL_SAFE_NO_PAD; + Self { + private_pem: private + .to_pkcs1_pem(rsa::pkcs1::LineEnding::LF) + .expect("encode RSA private key as PEM") + .to_string(), + modulus_b64: b64.encode(private.n().to_bytes_be()), + exponent_b64: b64.encode(private.e().to_bytes_be()), + } + } + } + + #[test] + fn delegated_refresh_allows_insecure_http_only_for_same_http_origin() { + assert!(delegated_refresh_allows_insecure_http( + "http://keycloak.127.0.0.1.sslip.io:9090/realms/openshell", + "http://keycloak.127.0.0.1.sslip.io:9090/realms/openshell/protocol/openid-connect/token", + )); + assert!(!delegated_refresh_allows_insecure_http( + "https://idp.example.com/realms/openshell", + "http://idp.example.com/realms/openshell/protocol/openid-connect/token", + )); + assert!(!delegated_refresh_allows_insecure_http( + "http://idp.example.com/realms/openshell", + "http://metadata.internal/token", + )); + assert!(!delegated_refresh_allows_insecure_http( + "not an issuer url", + "http://idp.example.com/token", + )); + } + + #[test] + fn delegated_refresh_error_message_explains_inactive_session_recovery() { + let message = delegated_refresh_error_message( + "token grant failed with status 400 Bad Request: error=invalid_grant; error_description=Session not active", + ); + + assert!(message.contains("delegated credential refresh failed")); + assert!(message.contains("stored delegated identity refresh token is no longer active")); + assert!(message.contains("openshell sandbox delegated-identity extend ")); + } + + #[test] + fn revoked_delegated_credential_rejects_upsert_reactivation() { + let active = DelegatedIdentityCredential { + revoked_at_ms: 0, + ..Default::default() + }; + ensure_delegated_credential_not_revoked(&active).expect("active credential is reusable"); + + let revoked = DelegatedIdentityCredential { + revoked_at_ms: 42, + ..Default::default() + }; + let status = ensure_delegated_credential_not_revoked(&revoked) + .expect_err("revoked credential must stay revoked"); + + assert_eq!(status.code(), Code::FailedPrecondition); + assert!(status.message().contains("credential is revoked")); + } + + #[test] + fn delegated_access_token_subject_must_match_authenticated_caller() { + ensure_delegated_token_subject_matches("user-a", "user-a") + .expect("matching subject should be accepted"); + + let status = ensure_delegated_token_subject_matches("user-b", "user-a") + .expect_err("mismatched subject must be rejected"); + + assert_eq!(status.code(), Code::PermissionDenied); + assert!(status.message().contains("subject must match")); + } + + #[test] + fn delete_credential_resource_version_zero_uses_current_version() { + let credential = DelegatedIdentityCredential { + metadata: Some(ObjectMeta { + id: "delegated-identity-test".to_string(), + name: "delegated-identity-test".to_string(), + resource_version: 7, + workspace: String::new(), + labels: HashMap::new(), + annotations: HashMap::new(), + ..Default::default() + }), + ..Default::default() + }; + + let version = effective_delete_credential_resource_version(Some(&credential), 0); + + assert_eq!(version, Some(7)); + assert_eq!(effective_delete_credential_resource_version(None, 0), None); + assert_eq!( + effective_delete_credential_resource_version(Some(&credential), 42), + Some(42) + ); + } + + #[test] + fn admin_credential_response_uses_non_secret_summary() { + let credential = DelegatedIdentityCredential { + issuer: "https://issuer.example.com".to_string(), + client_id: "openshell-cli".to_string(), + principal_subject: "user-1".to_string(), + refresh_token: "refresh-secret".to_string(), + access_token: "access-secret".to_string(), + access_token_expires_at_ms: 123, + scopes: "openid profile".to_string(), + audience: "api://resource".to_string(), + last_refresh_at_ms: 42, + revoked_at_ms: 0, + ..Default::default() + }; + + let summary = delegated_credential_summary(credential); + + assert!(summary.refresh_token_present); + assert!(summary.access_token_present); + assert_eq!(summary.issuer, "https://issuer.example.com"); + assert_eq!(summary.principal_subject, "user-1"); + assert_eq!(summary.access_token_expires_at_ms, 123); + } + + #[test] + fn delegated_credential_upsert_uses_existing_resource_version_for_cas() { + let credential = DelegatedIdentityCredential { + metadata: Some(ObjectMeta { + id: "delegated-identity-test".to_string(), + name: "delegated-identity-test".to_string(), + resource_version: 7, + workspace: String::new(), + labels: HashMap::new(), + annotations: HashMap::new(), + ..Default::default() + }), + ..Default::default() + }; + + assert!(matches!( + delegated_credential_upsert_condition(&credential), + WriteCondition::MatchResourceVersion(7) + )); + } + + #[test] + fn sandbox_status_reports_revoked_backing_credential() { + let credential = DelegatedIdentityCredential { + metadata: Some(ObjectMeta { + id: "delegated-identity-test".to_string(), + name: "delegated-identity-test".to_string(), + resource_version: 7, + workspace: String::new(), + labels: HashMap::new(), + annotations: HashMap::new(), + ..Default::default() + }), + revoked_at_ms: 42, + ..Default::default() + }; + + let (revoked_at_ms, missing) = delegated_credential_status_fields(Some(&credential)); + assert_eq!(revoked_at_ms, 42); + assert!(!missing); + assert_eq!(delegated_credential_status_fields(None), (0, true)); + } + + #[tokio::test] + async fn prepared_sandbox_create_cleanup_deletes_only_new_credentials() { + let state = test_server_state().await; + let new = put_test_credential(&state, "delegated-identity-new").await; + let reused = put_test_credential(&state, "delegated-identity-reused").await; + + delete_new_prepared_sandbox_credential(&state, Some(&prepared_test_delegation(&new, true))) + .await + .expect("new credential cleanup should succeed"); + delete_new_prepared_sandbox_credential( + &state, + Some(&prepared_test_delegation(&reused, false)), + ) + .await + .expect("reused credential cleanup should be a no-op"); + + assert!( + state + .store + .get_message::(new.object_id()) + .await + .unwrap() + .is_none() + ); + assert!( + state + .store + .get_message::(reused.object_id()) + .await + .unwrap() + .is_some() + ); + } + + #[tokio::test] + async fn delegated_refresh_rejects_access_token_for_different_subject() { + let server = wiremock::MockServer::start().await; + mount_test_oidc_issuer(&server).await; + let issuer = server.uri(); + let state = test_server_state_with_oidc(issuer.clone()).await; + let original_access_token = + mint_test_access_token(&issuer, "alice", current_time_secs() + 3600); + let mismatched_access_token = + mint_test_access_token(&issuer, "bob", current_time_secs() + 3600); + let credential = DelegatedIdentityCredential { + metadata: Some(ObjectMeta { + id: "delegated-identity-refresh".to_string(), + name: "delegated-identity-refresh".to_string(), + workspace: String::new(), + labels: HashMap::new(), + annotations: HashMap::new(), + ..Default::default() + }), + issuer: issuer.clone(), + client_id: TEST_AUDIENCE.to_string(), + principal_subject: "alice".to_string(), + refresh_token: "refresh-token".to_string(), + access_token: original_access_token.clone(), + access_token_expires_at_ms: current_time_ms() - 1, + scopes: "openid profile".to_string(), + ..Default::default() + }; + state.store.put_message(&credential).await.unwrap(); + let credential = state + .store + .get_message::("delegated-identity-refresh") + .await + .unwrap() + .unwrap(); + mount_refresh_token_response(&server, &mismatched_access_token).await; + + let status = super::refresh_if_needed(&state, credential) + .await + .expect_err("mismatched refreshed subject must be rejected"); + + assert_eq!(status.code(), Code::PermissionDenied); + assert!(status.message().contains("subject must match")); + let stored = state + .store + .get_message::("delegated-identity-refresh") + .await + .unwrap() + .unwrap(); + assert_eq!(stored.access_token, original_access_token); + assert_eq!(stored.principal_subject, "alice"); + } + + #[tokio::test] + async fn delegated_request_expiry_is_derived_from_validated_access_token() { + let server = wiremock::MockServer::start().await; + mount_test_oidc_issuer(&server).await; + let issuer = server.uri(); + let state = test_server_state_with_oidc(issuer.clone()).await; + let exp_secs = current_time_secs() + 1800; + let user = crate::auth::principal::UserPrincipal { + identity: crate::auth::identity::Identity { + subject: "alice".to_string(), + display_name: None, + roles: vec!["openshell-user".to_string()], + scopes: vec![], + provider: crate::auth::identity::IdentityProvider::Oidc, + }, + }; + let request = DelegatedIdentityRequest { + issuer: issuer.clone(), + client_id: TEST_AUDIENCE.to_string(), + refresh_token: "refresh-token".to_string(), + access_token: mint_test_access_token(&issuer, "alice", exp_secs), + delegated_until_ms: current_time_ms() + 600_000, + scopes: "openid profile".to_string(), + audience: TEST_AUDIENCE.to_string(), + }; + + let expires_at_ms = super::validate_delegation_request(&state, &user, &request) + .await + .expect("delegation request should validate"); + let upserted = super::upsert_credential(&state, &user, request, expires_at_ms) + .await + .expect("credential should persist"); + + assert_eq!(expires_at_ms, exp_secs.saturating_mul(1000)); + assert_eq!( + upserted.credential.access_token_expires_at_ms, + exp_secs.saturating_mul(1000) + ); + } + + #[tokio::test] + async fn extend_cleanup_deletes_new_credential_when_record_update_fails() { + let server = wiremock::MockServer::start().await; + mount_test_oidc_issuer(&server).await; + let issuer = server.uri(); + let state = test_server_state_with_oidc(issuer.clone()).await; + put_test_sandbox(&state, "delegated").await; + let existing_credential = + put_test_credential_for_subject(&state, "delegated-identity-existing", "dev-user") + .await; + let sandbox_id = "sandbox-delegated"; + let record_id = sandbox_delegated_identity_record_id(sandbox_id); + let malformed_record = SandboxDelegatedIdentityRecord { + metadata: Some(ObjectMeta { + id: String::new(), + name: record_id.clone(), + workspace: "default".to_string(), + labels: HashMap::new(), + annotations: HashMap::new(), + ..Default::default() + }), + sandbox_id: sandbox_id.to_string(), + delegated_identity: Some(SandboxDelegatedIdentity { + credential_id: existing_credential.object_id().to_string(), + principal_subject: "dev-user".to_string(), + delegated_until_ms: current_time_ms() + 600_000, + withdrawn_at_ms: 0, + }), + }; + state + .store + .put_scoped( + SandboxDelegatedIdentityRecord::object_type(), + &record_id, + &record_id, + "default", + sandbox_id, + &malformed_record.encode_to_vec(), + None, + ) + .await + .expect("store malformed record under valid lookup key"); + + let new_client_id = "openshell-cli-extend"; + let new_credential_id = delegated_credential_id(&issuer, new_client_id, "dev-user"); + let request = authed_request(ExtendSandboxDelegatedIdentityRequest { + name: "delegated".to_string(), + workspace: "default".to_string(), + delegated_identity: Some(DelegatedIdentityRequest { + issuer: issuer.clone(), + client_id: new_client_id.to_string(), + refresh_token: "new-refresh".to_string(), + access_token: mint_test_access_token( + &issuer, + "dev-user", + current_time_secs() + 3600, + ), + delegated_until_ms: current_time_ms() + 600_000, + scopes: "openid profile".to_string(), + audience: TEST_AUDIENCE.to_string(), + }), + }); + + let status = super::handle_extend(&state, request) + .await + .expect_err("record update failure should fail extend"); + + assert!( + status.message().contains("extend delegated identity"), + "unexpected error: {status:?}" + ); + assert!( + state + .store + .get_message::(&new_credential_id) + .await + .unwrap() + .is_none(), + "newly-created credential should be cleaned up" + ); + assert!( + state + .store + .get_message::(existing_credential.object_id()) + .await + .unwrap() + .is_some(), + "pre-existing credential should not be cleaned up" + ); + } + + #[tokio::test] + async fn sandbox_delegated_identity_status_reports_disabled_for_regular_sandbox() { + let state = test_server_state().await; + put_test_sandbox(&state, "regular").await; + + let response = super::handle_status( + &state, + authed_request(GetSandboxDelegatedIdentityStatusRequest { + name: "regular".to_string(), + workspace: "default".to_string(), + }), + ) + .await + .expect("regular sandbox status should report disabled") + .into_inner(); + + assert!(response.delegated_identity.is_none()); + assert!(response.credential_missing); + assert_eq!(response.credential_revoked_at_ms, 0); + assert!(response.now_ms > 0); + } + + #[tokio::test] + async fn sandbox_delegated_identity_status_rejects_non_delegating_user() { + let state = test_server_state().await; + put_test_sandbox(&state, "delegated").await; + let credential = put_test_credential(&state, "delegated-identity-status").await; + state + .store + .put_scoped_message( + &SandboxDelegatedIdentityRecord { + metadata: Some(ObjectMeta { + id: "sandbox-delegated-identity-sandbox-delegated".to_string(), + name: "sandbox-delegated-identity-sandbox-delegated".to_string(), + workspace: "default".to_string(), + labels: HashMap::new(), + annotations: HashMap::new(), + ..Default::default() + }), + sandbox_id: "sandbox-delegated".to_string(), + delegated_identity: Some(SandboxDelegatedIdentity { + credential_id: credential.object_id().to_string(), + principal_subject: "alice".to_string(), + delegated_until_ms: 2_000_000, + withdrawn_at_ms: 0, + }), + }, + "sandbox-delegated", + ) + .await + .unwrap(); + + let mut request = Request::new(GetSandboxDelegatedIdentityStatusRequest { + name: "delegated".to_string(), + workspace: "default".to_string(), + }); + request + .extensions_mut() + .insert(crate::auth::principal::Principal::User( + crate::auth::principal::UserPrincipal { + identity: crate::auth::identity::Identity { + subject: "bob".to_string(), + display_name: None, + roles: vec!["openshell-user".to_string()], + scopes: vec![], + provider: crate::auth::identity::IdentityProvider::Oidc, + }, + }, + )); + + let status = super::handle_status(&state, request) + .await + .expect_err("non-delegating user should be rejected"); + + assert_eq!(status.code(), Code::PermissionDenied); + assert!(status.message().contains("delegating principal")); + } + + async fn put_test_credential( + state: &Arc, + id: &str, + ) -> DelegatedIdentityCredential { + put_test_credential_for_subject(state, id, "user-1").await + } + + async fn put_test_credential_for_subject( + state: &Arc, + id: &str, + subject: &str, + ) -> DelegatedIdentityCredential { + let credential = DelegatedIdentityCredential { + metadata: Some(ObjectMeta { + id: id.to_string(), + name: id.to_string(), + workspace: String::new(), + labels: HashMap::new(), + annotations: HashMap::new(), + ..Default::default() + }), + issuer: "https://issuer.example.com".to_string(), + client_id: "openshell-cli".to_string(), + principal_subject: subject.to_string(), + refresh_token: "refresh".to_string(), + access_token: "access".to_string(), + ..Default::default() + }; + state.store.put_message(&credential).await.unwrap(); + state + .store + .get_message::(id) + .await + .unwrap() + .unwrap() + } + + async fn put_test_sandbox(state: &Arc, name: &str) { + state + .store + .put_message(&Sandbox { + metadata: Some(ObjectMeta { + id: format!("sandbox-{name}"), + name: name.to_string(), + workspace: "default".to_string(), + labels: HashMap::new(), + annotations: HashMap::new(), + ..Default::default() + }), + spec: Some(SandboxSpec::default()), + status: Some(SandboxStatus::default()), + }) + .await + .unwrap(); + } + + fn prepared_test_delegation( + credential: &DelegatedIdentityCredential, + credential_created: bool, + ) -> PreparedSandboxDelegatedIdentity { + PreparedSandboxDelegatedIdentity { + record: SandboxDelegatedIdentityRecord { + metadata: Some(ObjectMeta { + id: format!("sandbox-delegated-identity-{credential_created}"), + name: format!("sandbox-delegated-identity-{credential_created}"), + workspace: "default".to_string(), + labels: HashMap::new(), + annotations: HashMap::new(), + ..Default::default() + }), + sandbox_id: "sandbox-test".to_string(), + delegated_identity: Some(SandboxDelegatedIdentity { + credential_id: credential.object_id().to_string(), + principal_subject: credential.principal_subject.clone(), + delegated_until_ms: 2_000_000, + withdrawn_at_ms: 0, + }), + }, + credential_id: credential.object_id().to_string(), + credential_resource_version: credential.get_resource_version(), + credential_created, + } + } + + async fn test_server_state_with_oidc(issuer: String) -> Arc { + let store = Arc::new( + Store::connect("sqlite::memory:?cache=shared") + .await + .unwrap(), + ); + crate::ensure_default_workspace(&store).await.unwrap(); + let compute = crate::compute::new_test_runtime(store.clone()).await; + let oidc = OidcConfig { + issuer, + audience: TEST_AUDIENCE.to_string(), + jwks_ttl_secs: 3600, + roles_claim: "realm_access.roles".to_string(), + admin_role: "openshell-admin".to_string(), + user_role: "openshell-user".to_string(), + scopes_claim: "scope".to_string(), + }; + let oidc_cache = Arc::new( + crate::auth::oidc::JwksCache::new(&oidc) + .await + .expect("OIDC cache should build from mock issuer"), + ); + Arc::new(crate::ServerState::new( + Config::new(None) + .with_database_url("sqlite::memory:?cache=shared") + .with_credential_drivers(["test-static"]) + .with_oidc(oidc), + store, + compute, + SandboxIndex::new(), + SandboxWatchBus::new(), + TracingLogBus::new(), + Arc::new(SupervisorSessionRegistry::new()), + Some(oidc_cache), + )) + } + + async fn mount_test_oidc_issuer(server: &wiremock::MockServer) { + use wiremock::matchers::{method, path}; + use wiremock::{Mock, ResponseTemplate}; + + let issuer = server.uri(); + Mock::given(method("GET")) + .and(path("/.well-known/openid-configuration")) + .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({ + "issuer": issuer, + "jwks_uri": format!("{issuer}/jwks"), + "token_endpoint": format!("{issuer}/token"), + }))) + .mount(server) + .await; + Mock::given(method("GET")) + .and(path("/jwks")) + .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({ + "keys": [{ + "kid": TEST_KID, + "kty": "RSA", + "n": TEST_RSA_KEY.modulus_b64, + "e": TEST_RSA_KEY.exponent_b64, + }], + }))) + .mount(server) + .await; + } + + async fn mount_refresh_token_response(server: &wiremock::MockServer, access_token: &str) { + use wiremock::matchers::{method, path}; + use wiremock::{Mock, ResponseTemplate}; + + Mock::given(method("POST")) + .and(path("/token")) + .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({ + "access_token": access_token, + "token_type": "Bearer", + "expires_in": 3600, + }))) + .mount(server) + .await; + } + + fn mint_test_access_token(issuer: &str, subject: &str, exp: i64) -> String { + crate::install_jsonwebtoken_crypto_provider(); + + let mut header = jsonwebtoken::Header::new(jsonwebtoken::Algorithm::RS256); + header.kid = Some(TEST_KID.to_string()); + let key = jsonwebtoken::EncodingKey::from_rsa_pem(TEST_RSA_KEY.private_pem.as_bytes()) + .expect("load RSA signing key"); + jsonwebtoken::encode( + &header, + &serde_json::json!({ + "sub": subject, + "preferred_username": subject, + "iss": issuer, + "aud": TEST_AUDIENCE, + "exp": exp, + "scope": "openid profile sandbox:write", + "realm_access": { "roles": ["openshell-user"] }, + }), + &key, + ) + .expect("sign RS256 token") + } + + fn current_time_secs() -> i64 { + i64::try_from( + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .expect("system clock is after the unix epoch") + .as_secs(), + ) + .expect("current time fits in i64") + } +} diff --git a/crates/openshell-server/src/grpc/mod.rs b/crates/openshell-server/src/grpc/mod.rs index 957a77cbac..c3034beaca 100644 --- a/crates/openshell-server/src/grpc/mod.rs +++ b/crates/openshell-server/src/grpc/mod.rs @@ -18,25 +18,30 @@ use openshell_core::proto::{ ClearDraftChunksResponse, ComputeDriverCapabilities, ComputeDriverInfo, ConfigureProviderRefreshRequest, ConfigureProviderRefreshResponse, CreateProviderRequest, CreateSandboxRequest, CreateSshSessionRequest, CreateSshSessionResponse, - CreateWorkspaceRequest, CreateWorkspaceResponse, DeleteProviderProfileRequest, + CreateWorkspaceRequest, CreateWorkspaceResponse, DeleteDelegatedIdentityCredentialRequest, + DeleteDelegatedIdentityCredentialResponse, DeleteProviderProfileRequest, DeleteProviderProfileResponse, DeleteProviderRefreshRequest, DeleteProviderRefreshResponse, DeleteProviderRequest, DeleteProviderResponse, DeleteSandboxRequest, DeleteSandboxResponse, DeleteServiceRequest, DeleteServiceResponse, DeleteWorkspaceRequest, DeleteWorkspaceResponse, DetachSandboxProviderRequest, DetachSandboxProviderResponse, EditDraftChunkRequest, EditDraftChunkResponse, ExchangeProviderSubjectTokenRequest, ExchangeProviderSubjectTokenResponse, ExecSandboxEvent, ExecSandboxInput, ExecSandboxRequest, - ExposeServiceRequest, FinalizeMainProcessExitRequest, FinalizeMainProcessExitResponse, - GatewayMessage, GetCurrentUserRequest, GetCurrentUserResponse, GetDraftHistoryRequest, - GetDraftHistoryResponse, GetDraftPolicyRequest, GetDraftPolicyResponse, + ExposeServiceRequest, ExtendSandboxDelegatedIdentityRequest, + ExtendSandboxDelegatedIdentityResponse, FinalizeMainProcessExitRequest, + FinalizeMainProcessExitResponse, GatewayMessage, GetCurrentUserRequest, GetCurrentUserResponse, + GetDelegatedIdentityCredentialStatusRequest, GetDelegatedIdentityCredentialStatusResponse, + GetDraftHistoryRequest, GetDraftHistoryResponse, GetDraftPolicyRequest, GetDraftPolicyResponse, GetGatewayConfigRequest, GetGatewayConfigResponse, GetGatewayInfoRequest, GetGatewayInfoResponse, GetProviderProfileRequest, GetProviderRefreshStatusRequest, GetProviderRefreshStatusResponse, GetProviderRequest, GetSandboxConfigRequest, - GetSandboxConfigResponse, GetSandboxLogsRequest, GetSandboxLogsResponse, + GetSandboxConfigResponse, GetSandboxDelegatedIdentityStatusRequest, + GetSandboxDelegatedIdentityStatusResponse, GetSandboxLogsRequest, GetSandboxLogsResponse, GetSandboxPolicyStatusRequest, GetSandboxPolicyStatusResponse, GetSandboxProviderEnvironmentRequest, GetSandboxProviderEnvironmentResponse, GetSandboxRequest, GetServiceRequest, GetWorkspaceRequest, GetWorkspaceResponse, HealthRequest, HealthResponse, ImportProviderProfilesRequest, ImportProviderProfilesResponse, IssueSandboxTokenRequest, IssueSandboxTokenResponse, LintProviderProfilesRequest, LintProviderProfilesResponse, + ListDelegatedIdentityCredentialsRequest, ListDelegatedIdentityCredentialsResponse, ListProviderProfilesRequest, ListProviderProfilesResponse, ListProvidersRequest, ListProvidersResponse, ListSandboxPoliciesRequest, ListSandboxPoliciesResponse, ListSandboxProvidersRequest, ListSandboxProvidersResponse, ListSandboxesRequest, @@ -46,14 +51,16 @@ use openshell_core::proto::{ RefreshSandboxTokenRequest, RefreshSandboxTokenResponse, RejectDraftChunkRequest, RejectDraftChunkResponse, RelayFrame, RemoveWorkspaceMemberRequest, RemoveWorkspaceMemberResponse, ReportMainProcessExitRequest, ReportMainProcessExitResponse, - ReportPolicyStatusRequest, ReportPolicyStatusResponse, RevokeSshSessionRequest, - RevokeSshSessionResponse, RotateProviderCredentialRequest, RotateProviderCredentialResponse, - SandboxResponse, ServiceEndpointResponse, ServiceStatus, StartSandboxRequest, - StopSandboxRequest, SubmitPolicyAnalysisRequest, SubmitPolicyAnalysisResponse, - SupervisorMessage, TcpForwardFrame, UndoDraftChunkRequest, UndoDraftChunkResponse, - UpdateConfigRequest, UpdateConfigResponse, UpdateProviderProfilesRequest, - UpdateProviderProfilesResponse, UpdateProviderRequest, WatchSandboxRequest, - open_shell_server::OpenShell, + ReportPolicyStatusRequest, ReportPolicyStatusResponse, + RevokeDelegatedIdentityCredentialRequest, RevokeDelegatedIdentityCredentialResponse, + RevokeSshSessionRequest, RevokeSshSessionResponse, RotateProviderCredentialRequest, + RotateProviderCredentialResponse, SandboxResponse, ServiceEndpointResponse, ServiceStatus, + StartSandboxRequest, StopSandboxRequest, SubmitPolicyAnalysisRequest, + SubmitPolicyAnalysisResponse, SupervisorMessage, TcpForwardFrame, UndoDraftChunkRequest, + UndoDraftChunkResponse, UpdateConfigRequest, UpdateConfigResponse, + UpdateProviderProfilesRequest, UpdateProviderProfilesResponse, UpdateProviderRequest, + WatchSandboxRequest, WithdrawSandboxDelegatedIdentityRequest, + WithdrawSandboxDelegatedIdentityResponse, open_shell_server::OpenShell, }; use serde::{Deserialize, Serialize}; use std::collections::BTreeMap; @@ -276,6 +283,27 @@ impl OpenShell for OpenShellService { sandbox::handle_create_sandbox(&self.state, request).await } + async fn get_sandbox_delegated_identity_status( + &self, + request: Request, + ) -> Result, Status> { + crate::delegated_identity::handle_status(&self.state, request).await + } + + async fn withdraw_sandbox_delegated_identity( + &self, + request: Request, + ) -> Result, Status> { + crate::delegated_identity::handle_withdraw(&self.state, request).await + } + + async fn extend_sandbox_delegated_identity( + &self, + request: Request, + ) -> Result, Status> { + crate::delegated_identity::handle_extend(&self.state, request).await + } + type WatchSandboxStream = sandbox::WatchSandboxStream; async fn watch_sandbox( @@ -552,6 +580,34 @@ impl OpenShell for OpenShellService { provider::handle_exchange_provider_subject_token(&self.state, request).await } + async fn list_delegated_identity_credentials( + &self, + request: Request, + ) -> Result, Status> { + crate::delegated_identity::handle_list_credentials(&self.state, request).await + } + + async fn get_delegated_identity_credential_status( + &self, + request: Request, + ) -> Result, Status> { + crate::delegated_identity::handle_get_credential_status(&self.state, request).await + } + + async fn revoke_delegated_identity_credential( + &self, + request: Request, + ) -> Result, Status> { + crate::delegated_identity::handle_revoke_credential(&self.state, request).await + } + + async fn delete_delegated_identity_credential( + &self, + request: Request, + ) -> Result, Status> { + crate::delegated_identity::handle_delete_credential(&self.state, request).await + } + async fn update_config( &self, request: Request, diff --git a/crates/openshell-server/src/grpc/policy.rs b/crates/openshell-server/src/grpc/policy.rs index 0bda93a15f..ed72c1f3c4 100644 --- a/crates/openshell-server/src/grpc/policy.rs +++ b/crates/openshell-server/src/grpc/policy.rs @@ -3434,6 +3434,8 @@ async fn handle_update_config_inner( .await .map_err(|e| Status::internal(format!("fetch sandbox failed: {e}")))? .ok_or_else(|| Status::not_found("sandbox not found"))?; + crate::delegated_identity::ensure_delegated_identity_sandbox_user(state, principal, &sandbox) + .await?; let sandbox_id = sandbox.object_id().to_string(); let mut response_annotations = sandbox_metadata_annotations(&sandbox); @@ -4203,6 +4205,8 @@ pub(super) async fn handle_submit_policy_analysis( &req.name, ) .await?; + crate::delegated_identity::ensure_delegated_identity_sandbox_user(state, &principal, &sandbox) + .await?; let sandbox_id = sandbox.object_id().to_string(); for summary in &req.network_activity_summaries { state @@ -4703,6 +4707,8 @@ async fn handle_approve_draft_chunk_inner( .await .map_err(|e| Status::internal(format!("fetch sandbox failed: {e}")))? .ok_or_else(|| Status::not_found("sandbox not found"))?; + crate::delegated_identity::ensure_delegated_identity_sandbox_user(state, &principal, &sandbox) + .await?; let sandbox_id = sandbox.object_id().to_string(); let chunk = state @@ -4856,6 +4862,8 @@ async fn handle_reject_draft_chunk_inner( .await .map_err(|e| Status::internal(format!("fetch sandbox failed: {e}")))? .ok_or_else(|| Status::not_found("sandbox not found"))?; + crate::delegated_identity::ensure_delegated_identity_sandbox_user(state, &principal, &sandbox) + .await?; let sandbox_id = sandbox.object_id().to_string(); let chunk = state @@ -4965,6 +4973,8 @@ async fn handle_approve_all_draft_chunks_inner( .await .map_err(|e| Status::internal(format!("fetch sandbox failed: {e}")))? .ok_or_else(|| Status::not_found("sandbox not found"))?; + crate::delegated_identity::ensure_delegated_identity_sandbox_user(state, &principal, &sandbox) + .await?; let sandbox_id = sandbox.object_id().to_string(); let pending_chunks = state @@ -5277,6 +5287,8 @@ pub(super) async fn handle_edit_draft_chunk( .await .map_err(|e| Status::internal(format!("fetch sandbox failed: {e}")))? .ok_or_else(|| Status::not_found("sandbox not found"))?; + crate::delegated_identity::ensure_delegated_identity_sandbox_user(state, &principal, &sandbox) + .await?; let sandbox_id = sandbox.object_id().to_string(); let chunk = state @@ -5355,6 +5367,8 @@ async fn handle_undo_draft_chunk_inner( .await .map_err(|e| Status::internal(format!("fetch sandbox failed: {e}")))? .ok_or_else(|| Status::not_found("sandbox not found"))?; + crate::delegated_identity::ensure_delegated_identity_sandbox_user(state, &principal, &sandbox) + .await?; let sandbox_id = sandbox.object_id().to_string(); let chunk = state @@ -5449,6 +5463,8 @@ pub(super) async fn handle_clear_draft_chunks( .await .map_err(|e| Status::internal(format!("fetch sandbox failed: {e}")))? .ok_or_else(|| Status::not_found("sandbox not found"))?; + crate::delegated_identity::ensure_delegated_identity_sandbox_user(state, &principal, &sandbox) + .await?; let sandbox_id = sandbox.object_id().to_string(); let deleted = state diff --git a/crates/openshell-server/src/grpc/provider.rs b/crates/openshell-server/src/grpc/provider.rs index c8c8149a82..c3734e3907 100644 --- a/crates/openshell-server/src/grpc/provider.rs +++ b/crates/openshell-server/src/grpc/provider.rs @@ -3646,23 +3646,46 @@ pub(super) async fn handle_exchange_provider_subject_token( .subject_token .as_ref() .ok_or_else(|| Status::failed_precondition("token_exchange subject_token is missing"))?; - if subject_token.source != "provider_credential" { - return Err(Status::failed_precondition( - "unsupported subject_token source", - )); - } - if !profile_proto - .credentials - .iter() - .any(|credential| credential.name == subject_token.credential) - { - return Err(Status::failed_precondition( - "subject token credential not declared by provider profile", - )); - } - let stored_subject_token = - resolve_subject_token_credential(&state.credentials, &provider, &subject_token.credential) - .await?; + let (stored_subject_token, subject_token_expires_at_ms, subject_cache_key) = + match subject_token.source.as_str() { + "provider_credential" => { + if !profile_proto + .credentials + .iter() + .any(|credential| credential.name == subject_token.credential) + { + return Err(Status::failed_precondition( + "subject token credential not declared by provider profile", + )); + } + ( + resolve_subject_token_credential( + &state.credentials, + &provider, + &subject_token.credential, + ) + .await?, + provider_credential_expires_at_ms(&provider, &subject_token.credential), + subject_token.credential.clone(), + ) + } + "sandbox_delegated_identity" => { + if !subject_token.credential.trim().is_empty() { + return Err(Status::failed_precondition( + "sandbox_delegated_identity subject_token must not set credential", + )); + } + let (access_token, expires_at_ms, credential_id) = + crate::delegated_identity::resolve_subject_access_token(state, &sandbox) + .await?; + (access_token, expires_at_ms, credential_id) + } + _ => { + return Err(Status::failed_precondition( + "unsupported subject_token source", + )); + } + }; let jwt_svid_audience = effective_jwt_svid_audience(&token_grant.token_endpoint, &token_grant.jwt_svid_audience); @@ -3679,7 +3702,7 @@ pub(super) async fn handle_exchange_provider_subject_token( let intermediate_cache_key = intermediate_token_cache_key(IntermediateTokenCacheKeyInput { provider: &provider, dynamic_credential: &req.credential_key, - subject_credential: &subject_token.credential, + subject_credential: &subject_cache_key, token_endpoint: &token_grant.token_endpoint, client_assertion_type: effective_client_assertion_type(&token_grant.client_assertion_type), subject_token_type: effective_token_type(&subject_token.subject_token_type), @@ -3711,7 +3734,7 @@ pub(super) async fn handle_exchange_provider_subject_token( sandbox_id = %req.sandbox_id, provider = %req.provider, credential_key = %req.credential_key, - subject_credential = %subject_token.credential, + subject_credential = %subject_cache_key, client_assertion_type = %effective_client_assertion_type(&token_grant.client_assertion_type), gateway_svid_issuer = %gateway_claims.iss, gateway_svid_subject = %gateway_claims.sub, @@ -3727,7 +3750,7 @@ pub(super) async fn handle_exchange_provider_subject_token( let cache_expires_at_ms = intermediate_token_cache_expires_at_ms( &token_response, token_grant.cache_ttl_seconds, - provider_credential_expires_at_ms(&provider, &subject_token.credential), + subject_token_expires_at_ms, supervisor_claims.exp, ); if cache_expires_at_ms > crate::persistence::current_time_ms() { diff --git a/crates/openshell-server/src/grpc/sandbox.rs b/crates/openshell-server/src/grpc/sandbox.rs index 403bece8b9..ad27a05ceb 100644 --- a/crates/openshell-server/src/grpc/sandbox.rs +++ b/crates/openshell-server/src/grpc/sandbox.rs @@ -11,7 +11,8 @@ use crate::ServerState; use crate::auth::workspace_authz::{ - MinWorkspaceRole, authorize_sandbox_workspace, authorize_workspace, require_platform_admin, + AuthGrant, MinWorkspaceRole, authorize_sandbox_workspace, authorize_workspace, + require_platform_admin, }; use crate::persistence::{ObjectLabels, ObjectType, WriteCondition, generate_name}; use futures::future; @@ -109,9 +110,12 @@ impl Drop for WatchSandboxStream { } } -/// Fetch a sandbox by ID and authorize the caller in one step, returning -/// `NOT_FOUND` for both missing and unauthorized sandboxes so that callers -/// cannot distinguish the two cases (CWE-203). +/// Fetch a sandbox by ID and authorize the caller in one step. +/// +/// Workspace RBAC denials are normalized to `NOT_FOUND`, matching the legacy +/// cross-workspace behavior. Delegated-identity denials remain +/// `PERMISSION_DENIED`: workspace users may see the sandbox, but only the +/// delegating principal may perform delegated-identity-sensitive operations. pub(super) async fn fetch_and_authorize_sandbox( state: &Arc, principal: &crate::auth::principal::Principal, @@ -138,6 +142,8 @@ pub(super) async fn fetch_and_authorize_sandbox( e } })?; + crate::delegated_identity::ensure_delegated_identity_sandbox_user(state, principal, &sandbox) + .await?; Ok(sandbox) } @@ -217,6 +223,7 @@ async fn handle_create_sandbox_inner( let principal = super::extract_principal(&request)?; let request = request.into_inner(); let await_main_process_attachment = request.await_main_process_attachment; + let delegated_identity_request = request.delegated_identity.clone(); let mut spec = request .spec .ok_or_else(|| Status::invalid_argument("spec is required"))?; @@ -346,6 +353,14 @@ async fn handle_create_sandbox_inner( status })?; + let delegated_identity = crate::delegated_identity::prepare_for_sandbox_create( + state, + &principal, + &sandbox, + delegated_identity_request, + ) + .await?; + // Mint the gateway JWT for singleplayer drivers. K8s sandboxes skip // this mint and bootstrap via `IssueSandboxToken` at supervisor // startup; identifying "is this K8s?" lives in the compute layer, so @@ -366,10 +381,63 @@ async fn handle_create_sandbox_inner( None => None, }; - let sandbox = state + if let Err(status) = crate::delegated_identity::store_prepared_sandbox_delegation( + state, + delegated_identity.as_ref(), + ) + .await + { + if let Err(cleanup_status) = + crate::delegated_identity::delete_new_prepared_sandbox_credential( + state, + delegated_identity.as_ref(), + ) + .await + { + warn!( + sandbox_id = %id, + error = %cleanup_status, + "failed to clean up prepared delegated credential after sandbox delegation persist failure" + ); + } + return Err(status); + } + let sandbox = match state .compute .create_sandbox(sandbox, sandbox_token, await_main_process_attachment) - .await?; + .await + { + Ok(sandbox) => sandbox, + Err(status) => { + if let Err(cleanup_status) = + crate::delegated_identity::delete_prepared_sandbox_delegation( + state, + delegated_identity.as_ref(), + ) + .await + { + warn!( + sandbox_id = %id, + error = %cleanup_status, + "failed to clean up prepared delegated identity after sandbox create failure" + ); + } + if let Err(cleanup_status) = + crate::delegated_identity::delete_new_prepared_sandbox_credential( + state, + delegated_identity.as_ref(), + ) + .await + { + warn!( + sandbox_id = %id, + error = %cleanup_status, + "failed to clean up prepared delegated credential after sandbox create failure" + ); + } + return Err(status); + } + }; info!( sandbox_id = %id, @@ -499,6 +567,8 @@ pub(super) async fn handle_list_sandbox_providers( .await? .name; let sandbox = sandbox_by_name(state, &workspace, &req.sandbox_name).await?; + crate::delegated_identity::ensure_delegated_identity_sandbox_user(state, &principal, &sandbox) + .await?; let providers = providers_for_sandbox(state, &sandbox, &workspace).await?; Ok(Response::new(ListSandboxProvidersResponse { providers })) } @@ -549,6 +619,8 @@ pub(super) async fn handle_attach_sandbox_provider( let _sandbox_sync_guard = state.compute.sandbox_sync_guard().await; let sandbox = sandbox_by_name(state, &workspace, &request.sandbox_name).await?; + crate::delegated_identity::ensure_delegated_identity_sandbox_user(state, &principal, &sandbox) + .await?; let sandbox_id = sandbox .metadata .as_ref() @@ -684,6 +756,8 @@ pub(super) async fn handle_detach_sandbox_provider( let _sandbox_sync_guard = state.compute.sandbox_sync_guard().await; let sandbox = sandbox_by_name(state, &workspace, &request.sandbox_name).await?; + crate::delegated_identity::ensure_delegated_identity_sandbox_user(state, &principal, &sandbox) + .await?; let sandbox_id = sandbox .metadata .as_ref() @@ -789,6 +863,16 @@ async fn handle_delete_sandbox_inner( let workspace = super::workspace::resolve_workspace(state.store.as_ref(), &authz.workspace) .await? .name; + let sandbox = sandbox_by_name(state, &workspace, &name).await?; + if !matches!( + authz.grant, + AuthGrant::PlatformAdmin | AuthGrant::Member(openshell_core::proto::WorkspaceRole::Admin) + ) { + crate::delegated_identity::ensure_delegated_identity_sandbox_user( + state, &principal, &sandbox, + ) + .await?; + } let result = state.compute.delete_sandbox(&workspace, &name).await?; if result.deleted { @@ -1840,6 +1924,14 @@ pub(super) async fn handle_revoke_ssh_session( e } })?; + let sandbox = state + .store + .get_message::(&session.sandbox_id) + .await + .map_err(|e| Status::internal(format!("fetch sandbox failed: {e}")))? + .ok_or_else(|| Status::not_found("sandbox not found"))?; + crate::delegated_identity::ensure_delegated_identity_sandbox_user(state, &principal, &sandbox) + .await?; let resource_version = session .metadata @@ -2450,12 +2542,17 @@ async fn run_exec_with_russh( #[cfg(test)] mod tests { use super::*; + use crate::auth::identity::{Identity, IdentityProvider}; + use crate::auth::principal::{Principal, UserPrincipal}; use crate::grpc::test_support::{ authed_request, test_server_state, test_server_state_with_driver, }; use crate::provider_profile_sources::ProviderProfileSources; use openshell_core::GatewayProviderProfileSourceConfig; use openshell_core::proto::datamodel::v1::ObjectMeta; + use openshell_core::proto::{ + SandboxDelegatedIdentity, SandboxDelegatedIdentityRecord, WorkspaceMember, WorkspaceRole, + }; async fn test_server_state_with_user_only_github_profile() -> Arc { let mut state = test_server_state().await; @@ -2852,6 +2949,100 @@ mod tests { sandbox } + async fn put_delegated_test_sandbox( + state: &Arc, + name: &str, + principal_subject: &str, + ) { + let sandbox = test_sandbox(name, Vec::new()); + let sandbox_id = sandbox.object_id().to_string(); + let record_id = + crate::delegated_identity::sandbox_delegated_identity_record_id(&sandbox_id); + let workspace = sandbox.object_workspace().to_string(); + state.store.put_message(&sandbox).await.unwrap(); + state + .store + .put_scoped_message( + &SandboxDelegatedIdentityRecord { + metadata: Some(ObjectMeta { + id: record_id.clone(), + name: record_id, + created_at_ms: 1_000_000, + labels: HashMap::new(), + resource_version: 0, + annotations: HashMap::new(), + workspace, + deletion_timestamp_ms: 0, + }), + sandbox_id: sandbox_id.clone(), + delegated_identity: Some(SandboxDelegatedIdentity { + credential_id: "delegated-credential".to_string(), + principal_subject: principal_subject.to_string(), + delegated_until_ms: 2_000_000, + withdrawn_at_ms: 0, + }), + }, + &sandbox_id, + ) + .await + .unwrap(); + } + + async fn put_workspace_member(state: &Arc, subject: &str, role: WorkspaceRole) { + state + .store + .put_message(&WorkspaceMember { + metadata: Some(ObjectMeta { + id: format!("workspace-member-{subject}"), + name: subject.to_string(), + created_at_ms: 1_000_000, + labels: HashMap::new(), + resource_version: 0, + annotations: HashMap::new(), + workspace: "default".to_string(), + deletion_timestamp_ms: 0, + }), + principal_subject: subject.to_string(), + role: role.into(), + }) + .await + .unwrap(); + } + + fn user_request(mut request: Request, subject: &str) -> Request { + request + .extensions_mut() + .insert(Principal::User(UserPrincipal { + identity: Identity { + subject: subject.to_string(), + display_name: None, + roles: vec![], + scopes: vec![], + provider: IdentityProvider::Oidc, + }, + })); + request + } + + fn user_request_with_roles( + mut request: Request, + subject: &str, + roles: &[&str], + ) -> Request { + request + .extensions_mut() + .insert(Principal::User(UserPrincipal { + identity: Identity { + subject: subject.to_string(), + display_name: None, + roles: roles.iter().map(|role| (*role).to_string()).collect(), + scopes: vec![], + provider: IdentityProvider::Oidc, + }, + })); + request + } + #[tokio::test] #[ignore = "flaky under concurrent test execution"] async fn watch_producer_releases_request_span_when_client_disconnects() { @@ -3410,6 +3601,7 @@ mod tests { annotations: HashMap::new(), workspace: String::new(), await_main_process_attachment: false, + delegated_identity: None, }), ) .await @@ -3434,6 +3626,7 @@ mod tests { annotations: HashMap::new(), workspace: String::new(), await_main_process_attachment: false, + delegated_identity: None, }), ) .await @@ -3470,6 +3663,7 @@ mod tests { annotations: HashMap::new(), workspace: String::new(), await_main_process_attachment: false, + delegated_identity: None, }), ) .await @@ -3495,6 +3689,7 @@ mod tests { annotations: HashMap::from([(annotation_key.clone(), annotation_value.clone())]), workspace: String::new(), await_main_process_attachment: false, + delegated_identity: None, }), ) .await @@ -3556,6 +3751,7 @@ mod tests { annotations: HashMap::new(), workspace: String::new(), await_main_process_attachment: false, + delegated_identity: None, }), ) .await @@ -3622,6 +3818,7 @@ mod tests { annotations: HashMap::new(), workspace: String::new(), await_main_process_attachment: false, + delegated_identity: None, }), ) .await @@ -3653,6 +3850,7 @@ mod tests { annotations: HashMap::new(), workspace: String::new(), await_main_process_attachment: false, + delegated_identity: None, }), ) .await @@ -3686,6 +3884,7 @@ mod tests { annotations: HashMap::new(), workspace: String::new(), await_main_process_attachment: false, + delegated_identity: None, }), ) .await @@ -4016,6 +4215,213 @@ mod tests { assert!(!sandbox_relay_reachable(&state, &sandbox)); } + #[tokio::test] + async fn delegated_identity_sandbox_allows_delegating_user_to_create_ssh_session() { + let state = test_server_state().await; + put_delegated_test_sandbox(&state, "work", "alice").await; + + let response = handle_create_ssh_session( + &state, + user_request( + Request::new(CreateSshSessionRequest { + sandbox_id: "sandbox-work".to_string(), + }), + "alice", + ), + ) + .await + .expect("delegating user should be allowed") + .into_inner(); + + assert_eq!(response.sandbox_id, "sandbox-work"); + } + + #[tokio::test] + async fn delegated_identity_sandbox_rejects_other_user_create_ssh_session() { + let state = test_server_state().await; + put_delegated_test_sandbox(&state, "work", "alice").await; + + let err = handle_create_ssh_session( + &state, + user_request( + Request::new(CreateSshSessionRequest { + sandbox_id: "sandbox-work".to_string(), + }), + "bob", + ), + ) + .await + .expect_err("non-delegating user should be denied"); + + assert_eq!(err.code(), tonic::Code::PermissionDenied); + assert!(err.message().contains("delegating principal")); + } + + #[tokio::test] + async fn delegated_identity_sandbox_remains_visible_to_workspace_user() { + let state = test_server_state().await; + put_delegated_test_sandbox(&state, "work", "alice").await; + + let response = handle_get_sandbox( + &state, + user_request( + Request::new(GetSandboxRequest { + name: "work".to_string(), + workspace: "default".to_string(), + }), + "bob", + ), + ) + .await + .expect("workspace user should still see the sandbox") + .into_inner(); + assert_eq!( + response.sandbox.as_ref().unwrap().object_id(), + "sandbox-work" + ); + + let response = handle_list_sandboxes( + &state, + user_request( + Request::new(ListSandboxesRequest { + limit: 100, + offset: 0, + label_selector: String::new(), + workspace: "default".to_string(), + all_workspaces: false, + }), + "bob", + ), + ) + .await + .expect("workspace user should still list the sandbox") + .into_inner(); + assert_eq!(response.sandboxes.len(), 1); + assert_eq!(response.sandboxes[0].object_id(), "sandbox-work"); + } + + #[tokio::test] + async fn delegated_identity_sandbox_rejects_other_user_delete() { + let mut state = test_server_state().await; + Arc::get_mut(&mut state).unwrap().admin_role = "openshell-admin".to_string(); + put_workspace_member(&state, "bob", WorkspaceRole::User).await; + put_delegated_test_sandbox(&state, "work", "alice").await; + + let err = handle_delete_sandbox( + &state, + user_request( + Request::new(DeleteSandboxRequest { + name: "work".to_string(), + workspace: "default".to_string(), + }), + "bob", + ), + ) + .await + .expect_err("non-delegating user should be denied"); + + assert_eq!(err.code(), tonic::Code::PermissionDenied); + assert!(err.message().contains("delegating principal")); + assert!( + state + .store + .get_message::("sandbox-work") + .await + .unwrap() + .is_some(), + "denied delete must not remove the sandbox" + ); + } + + #[tokio::test] + async fn delegated_identity_sandbox_allows_workspace_admin_delete() { + let mut state = test_server_state().await; + Arc::get_mut(&mut state).unwrap().admin_role = "openshell-admin".to_string(); + put_workspace_member(&state, "bob", WorkspaceRole::Admin).await; + put_delegated_test_sandbox(&state, "work", "alice").await; + + let response = handle_delete_sandbox( + &state, + user_request( + Request::new(DeleteSandboxRequest { + name: "work".to_string(), + workspace: "default".to_string(), + }), + "bob", + ), + ) + .await + .expect("workspace admin should be allowed to delete delegated sandbox") + .into_inner(); + + assert!(response.deleted); + } + + #[tokio::test] + async fn delegated_identity_sandbox_allows_platform_admin_delete() { + let mut state = test_server_state().await; + Arc::get_mut(&mut state).unwrap().admin_role = "openshell-admin".to_string(); + put_delegated_test_sandbox(&state, "work", "alice").await; + + let response = handle_delete_sandbox( + &state, + user_request_with_roles( + Request::new(DeleteSandboxRequest { + name: "work".to_string(), + workspace: "default".to_string(), + }), + "bob", + &["openshell-admin"], + ), + ) + .await + .expect("platform admin should be allowed to delete delegated sandbox") + .into_inner(); + + assert!(response.deleted); + } + + #[tokio::test] + async fn delegated_identity_sandbox_rejects_other_user_revoke_ssh_session() { + let state = test_server_state().await; + put_delegated_test_sandbox(&state, "work", "alice").await; + let token = handle_create_ssh_session( + &state, + user_request( + Request::new(CreateSshSessionRequest { + sandbox_id: "sandbox-work".to_string(), + }), + "alice", + ), + ) + .await + .unwrap() + .into_inner() + .token; + + let err = handle_revoke_ssh_session( + &state, + user_request( + Request::new(RevokeSshSessionRequest { + token: token.clone(), + }), + "bob", + ), + ) + .await + .expect_err("non-delegating user should be denied"); + + assert_eq!(err.code(), tonic::Code::PermissionDenied); + assert!(err.message().contains("delegating principal")); + let session = state + .store + .get_message::(&token) + .await + .unwrap() + .expect("session should still exist after denied revocation"); + assert!(!session.revoked); + } + #[tokio::test] async fn concurrent_revoke_ssh_session_handles_cas_properly() { let state = test_server_state().await; diff --git a/crates/openshell-server/src/grpc/service.rs b/crates/openshell-server/src/grpc/service.rs index 790e26d618..6da17e1072 100644 --- a/crates/openshell-server/src/grpc/service.rs +++ b/crates/openshell-server/src/grpc/service.rs @@ -51,6 +51,8 @@ pub(super) async fn handle_expose_service( .await .map_err(|e| Status::internal(format!("fetch sandbox failed: {e}")))? .ok_or_else(|| Status::not_found("sandbox not found"))?; + crate::delegated_identity::ensure_delegated_identity_sandbox_user(state, &principal, &sandbox) + .await?; let now = crate::persistence::current_time_ms(); let key = service_routing::endpoint_key(&req.sandbox, &req.service); @@ -255,6 +257,14 @@ pub(super) async fn handle_delete_service( let Some(endpoint) = endpoint else { return Ok(Response::new(DeleteServiceResponse { deleted: false })); }; + let sandbox = state + .store + .get_message::(&endpoint.sandbox_id) + .await + .map_err(|e| Status::internal(format!("fetch sandbox failed: {e}")))? + .ok_or_else(|| Status::not_found("sandbox not found"))?; + crate::delegated_identity::ensure_delegated_identity_sandbox_user(state, &principal, &sandbox) + .await?; let key = service_routing::endpoint_key(&req.sandbox, &req.service); let deleted = state diff --git a/crates/openshell-server/src/lib.rs b/crates/openshell-server/src/lib.rs index 3dc2acec06..e9b8d58748 100644 --- a/crates/openshell-server/src/lib.rs +++ b/crates/openshell-server/src/lib.rs @@ -20,6 +20,7 @@ mod compute; pub mod config_file; mod credentials; mod defaults; +mod delegated_identity; mod gateway_listener; mod grpc; mod http; diff --git a/crates/openshell-server/tests/common/mod.rs b/crates/openshell-server/tests/common/mod.rs index 9e3957abb6..78fd23dc0e 100644 --- a/crates/openshell-server/tests/common/mod.rs +++ b/crates/openshell-server/tests/common/mod.rs @@ -112,6 +112,30 @@ impl OpenShell for TestOpenShell { Err(Status::unimplemented("unused")) } + async fn get_sandbox_delegated_identity_status( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn withdraw_sandbox_delegated_identity( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn extend_sandbox_delegated_identity( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + async fn get_sandbox( &self, _request: tonic::Request, @@ -135,6 +159,40 @@ impl OpenShell for TestOpenShell { )) } + async fn list_delegated_identity_credentials( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn get_delegated_identity_credential_status( + &self, + _request: tonic::Request< + openshell_core::proto::GetDelegatedIdentityCredentialStatusRequest, + >, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn revoke_delegated_identity_credential( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn delete_delegated_identity_credential( + &self, + _request: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + async fn attach_sandbox_provider( &self, _request: tonic::Request, diff --git a/crates/openshell-server/tests/supervisor_relay_integration.rs b/crates/openshell-server/tests/supervisor_relay_integration.rs index 6cfd3b009b..2a1ca0219e 100644 --- a/crates/openshell-server/tests/supervisor_relay_integration.rs +++ b/crates/openshell-server/tests/supervisor_relay_integration.rs @@ -99,6 +99,62 @@ impl OpenShell for RelayGateway { Err(Status::unimplemented("unused")) } + async fn get_sandbox_delegated_identity_status( + &self, + _: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn withdraw_sandbox_delegated_identity( + &self, + _: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn extend_sandbox_delegated_identity( + &self, + _: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn list_delegated_identity_credentials( + &self, + _: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn get_delegated_identity_credential_status( + &self, + _: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn revoke_delegated_identity_credential( + &self, + _: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + + async fn delete_delegated_identity_credential( + &self, + _: tonic::Request, + ) -> Result, Status> + { + Err(Status::unimplemented("unused")) + } + type ExecSandboxStream = ReceiverStream>; async fn exec_sandbox( diff --git a/crates/openshell-supervisor-network/src/token_grant.rs b/crates/openshell-supervisor-network/src/token_grant.rs index 15aea6fccf..210c86f9c8 100644 --- a/crates/openshell-supervisor-network/src/token_grant.rs +++ b/crates/openshell-supervisor-network/src/token_grant.rs @@ -60,6 +60,7 @@ static TOKEN_GRANT_HTTP_CLIENT: LazyLock = LazyLock::new(|| { const DEFAULT_TOKEN_CACHE_TTL_SECONDS: i64 = 300; const TOKEN_CACHE_EXPIRY_SKEW_SECONDS: i64 = 30; const MAX_TOKEN_EXPIRES_IN_SECONDS: i64 = 3600; +const MAX_TOKEN_EXCHANGE_CACHE_TTL_SECONDS: i64 = 300; /// Cached access token with expiration metadata. #[derive(Debug, Clone)] @@ -269,8 +270,11 @@ where let token_response = grant(jwt_audience).await?; - let cache_ttl_seconds = - token_cache_ttl_seconds(input.cache_ttl_override, token_response.expires_in); + let cache_ttl_seconds = token_cache_ttl_seconds( + input.cache_ttl_override, + token_response.expires_in, + input.grant_type, + ); let expires_at_ms = current_time_ms().saturating_add(cache_ttl_seconds.saturating_mul(1000)); input.cache.set( @@ -351,7 +355,11 @@ async fn perform_token_exchange( pub use oauth::validate_access_token; -fn token_cache_ttl_seconds(cache_ttl_override: i64, expires_in: i64) -> i64 { +fn token_cache_ttl_seconds( + cache_ttl_override: i64, + expires_in: i64, + grant_type: ProviderCredentialTokenGrantType, +) -> i64 { if cache_ttl_override > 0 { return cache_ttl_override; } @@ -361,10 +369,22 @@ fn token_cache_ttl_seconds(cache_ttl_override: i64, expires_in: i64) -> i64 { } else { DEFAULT_TOKEN_CACHE_TTL_SECONDS }; + let ttl = token_cache_ttl_cap_for_grant_type(ttl, grant_type); ttl.saturating_sub(TOKEN_CACHE_EXPIRY_SKEW_SECONDS).max(1) } +fn token_cache_ttl_cap_for_grant_type( + ttl_seconds: i64, + grant_type: ProviderCredentialTokenGrantType, +) -> i64 { + if grant_type == ProviderCredentialTokenGrantType::TokenExchange { + ttl_seconds.min(MAX_TOKEN_EXCHANGE_CACHE_TTL_SECONDS) + } else { + ttl_seconds + } +} + /// Derive the issuer/realm URL from a token endpoint URL. /// /// For Keycloak token endpoints like: @@ -660,6 +680,7 @@ mod tests { scopes: &'a [String], cache_ttl_override: i64, expires_in: i64, + grant_type: ProviderCredentialTokenGrantType, grant_calls: Arc, } @@ -674,7 +695,7 @@ mod tests { audience: input.audience, scopes: input.scopes, cache_ttl_override: input.cache_ttl_override, - grant_type: ProviderCredentialTokenGrantType::ClientCredentials, + grant_type: input.grant_type, requested_token_type: "", }, move |_| { @@ -692,26 +713,29 @@ mod tests { .await } - async fn obtain_token_without_grant_call( - cache: &TokenCache, - provider_name: &str, - token_endpoint: &str, - jwt_svid_audience: &str, - audience: &str, - scopes: &[String], + struct CachedTokenLookupInput<'a> { + cache: &'a TokenCache, + provider_name: &'a str, + token_endpoint: &'a str, + jwt_svid_audience: &'a str, + audience: &'a str, + scopes: &'a [String], cache_ttl_override: i64, - ) -> Result { + grant_type: ProviderCredentialTokenGrantType, + } + + async fn obtain_token_without_grant_call(input: CachedTokenLookupInput<'_>) -> Result { obtain_provider_token_with_grant( ObtainProviderTokenInput { - cache, - provider_name, - token_endpoint, - jwt_svid_audience, + cache: input.cache, + provider_name: input.provider_name, + token_endpoint: input.token_endpoint, + jwt_svid_audience: input.jwt_svid_audience, client_assertion_type: DEFAULT_CLIENT_ASSERTION_TYPE, - audience, - scopes, - cache_ttl_override, - grant_type: ProviderCredentialTokenGrantType::ClientCredentials, + audience: input.audience, + scopes: input.scopes, + cache_ttl_override: input.cache_ttl_override, + grant_type: input.grant_type, requested_token_type: "", }, |_| async { Err(miette::miette!("grant should not be called on cache hit")) }, @@ -850,24 +874,44 @@ mod tests { #[test] fn token_cache_ttl_uses_override_without_endpoint_skew() { - assert_eq!(token_cache_ttl_seconds(120, 10), 120); - assert_eq!(token_cache_ttl_seconds(120, i64::MAX), 120); + assert_eq!( + token_cache_ttl_seconds(120, 10, ProviderCredentialTokenGrantType::ClientCredentials), + 120 + ); + assert_eq!( + token_cache_ttl_seconds( + 120, + i64::MAX, + ProviderCredentialTokenGrantType::ClientCredentials, + ), + 120 + ); } #[test] fn token_cache_ttl_skews_default_and_response_expires_in() { assert_eq!( - token_cache_ttl_seconds(0, 0), + token_cache_ttl_seconds(0, 0, ProviderCredentialTokenGrantType::ClientCredentials), DEFAULT_TOKEN_CACHE_TTL_SECONDS - TOKEN_CACHE_EXPIRY_SKEW_SECONDS ); - assert_eq!(token_cache_ttl_seconds(0, 60), 30); - assert_eq!(token_cache_ttl_seconds(0, 10), 1); + assert_eq!( + token_cache_ttl_seconds(0, 60, ProviderCredentialTokenGrantType::ClientCredentials), + 30 + ); + assert_eq!( + token_cache_ttl_seconds(0, 10, ProviderCredentialTokenGrantType::ClientCredentials), + 1 + ); } #[test] fn token_cache_ttl_clamps_large_response_expires_in() { assert_eq!( - token_cache_ttl_seconds(0, i64::MAX), + token_cache_ttl_seconds( + 0, + i64::MAX, + ProviderCredentialTokenGrantType::ClientCredentials, + ), MAX_TOKEN_EXPIRES_IN_SECONDS - TOKEN_CACHE_EXPIRY_SKEW_SECONDS ); } @@ -887,19 +931,21 @@ mod tests { scopes: &scopes, cache_ttl_override: 0, expires_in: 60, + grant_type: ProviderCredentialTokenGrantType::ClientCredentials, grant_calls: grant_calls.clone(), }) .await .expect("first call should grant token"); - let second = obtain_token_without_grant_call( - &cache, - "api.example.test\t443\t/v1/**\tprovider:access_token", - "https://auth.example.com/token", - "https://auth.example.com", - "api://resource", - &scopes, - 0, - ) + let second = obtain_token_without_grant_call(CachedTokenLookupInput { + cache: &cache, + provider_name: "api.example.test\t443\t/v1/**\tprovider:access_token", + token_endpoint: "https://auth.example.com/token", + jwt_svid_audience: "https://auth.example.com", + audience: "api://resource", + scopes: &scopes, + cache_ttl_override: 0, + grant_type: ProviderCredentialTokenGrantType::ClientCredentials, + }) .await .expect("second call should use cache"); @@ -908,6 +954,64 @@ mod tests { assert_eq!(grant_calls.load(Ordering::SeqCst), 1); } + #[tokio::test] + async fn obtain_provider_token_uses_short_cache_for_token_exchange() { + let cache = TokenCache::new(); + let grant_calls = Arc::new(AtomicUsize::new(0)); + let scopes = vec!["read".to_string()]; + + let first = obtain_counted_test_token(CountedTokenGrantInput { + cache: &cache, + provider_name: "api.example.test\t443\t/v1/**\tprovider:access_token", + token_endpoint: "https://auth.example.com/token", + jwt_svid_audience: "https://auth.example.com", + audience: "api://resource", + scopes: &scopes, + cache_ttl_override: 0, + expires_in: 60, + grant_type: ProviderCredentialTokenGrantType::TokenExchange, + grant_calls: grant_calls.clone(), + }) + .await + .expect("first token exchange should grant token"); + let second = obtain_token_without_grant_call(CachedTokenLookupInput { + cache: &cache, + provider_name: "api.example.test\t443\t/v1/**\tprovider:access_token", + token_endpoint: "https://auth.example.com/token", + jwt_svid_audience: "https://auth.example.com", + audience: "api://resource", + scopes: &scopes, + cache_ttl_override: 0, + grant_type: ProviderCredentialTokenGrantType::TokenExchange, + }) + .await + .expect("second token exchange should use supervisor cache"); + + assert_eq!(first, "token-1"); + assert_eq!(second, "token-1"); + assert_eq!(grant_calls.load(Ordering::SeqCst), 1); + assert_eq!( + token_cache_ttl_seconds(0, i64::MAX, ProviderCredentialTokenGrantType::TokenExchange,), + MAX_TOKEN_EXCHANGE_CACHE_TTL_SECONDS - TOKEN_CACHE_EXPIRY_SKEW_SECONDS + ); + assert_eq!( + token_cache_ttl_seconds( + 120, + i64::MAX, + ProviderCredentialTokenGrantType::TokenExchange, + ), + 120 + ); + assert_eq!( + token_cache_ttl_seconds( + 600, + i64::MAX, + ProviderCredentialTokenGrantType::TokenExchange, + ), + 600 + ); + } + #[tokio::test] async fn obtain_provider_token_separates_cache_by_audience_and_scopes() { let cache = TokenCache::new(); @@ -924,6 +1028,7 @@ mod tests { scopes: &read_scope, cache_ttl_override: 0, expires_in: 60, + grant_type: ProviderCredentialTokenGrantType::ClientCredentials, grant_calls: grant_calls.clone(), }) .await @@ -937,6 +1042,7 @@ mod tests { scopes: &read_scope, cache_ttl_override: 0, expires_in: 60, + grant_type: ProviderCredentialTokenGrantType::ClientCredentials, grant_calls: grant_calls.clone(), }) .await @@ -950,6 +1056,7 @@ mod tests { scopes: &write_scope, cache_ttl_override: 0, expires_in: 60, + grant_type: ProviderCredentialTokenGrantType::ClientCredentials, grant_calls: grant_calls.clone(), }) .await @@ -996,6 +1103,7 @@ mod tests { scopes: &scopes, cache_ttl_override: 0, expires_in: 60, + grant_type: ProviderCredentialTokenGrantType::ClientCredentials, grant_calls: grant_calls.clone(), }) .await @@ -1020,19 +1128,21 @@ mod tests { scopes: &scopes, cache_ttl_override: 60, expires_in: 0, + grant_type: ProviderCredentialTokenGrantType::ClientCredentials, grant_calls: grant_calls.clone(), }) .await .expect("first override call should grant token"); - let second = obtain_token_without_grant_call( - &cache, - "api.example.test\t443\t/v1/**\tprovider:access_token", - "https://auth.example.com/token", - "https://auth.example.com", - "api://resource", - &scopes, - 60, - ) + let second = obtain_token_without_grant_call(CachedTokenLookupInput { + cache: &cache, + provider_name: "api.example.test\t443\t/v1/**\tprovider:access_token", + token_endpoint: "https://auth.example.com/token", + jwt_svid_audience: "https://auth.example.com", + audience: "api://resource", + scopes: &scopes, + cache_ttl_override: 60, + grant_type: ProviderCredentialTokenGrantType::ClientCredentials, + }) .await .expect("override should keep token cached"); diff --git a/crates/openshell-tui/src/lib.rs b/crates/openshell-tui/src/lib.rs index 625bc8a41a..fc9abb64c5 100644 --- a/crates/openshell-tui/src/lib.rs +++ b/crates/openshell-tui/src/lib.rs @@ -1408,6 +1408,7 @@ fn spawn_create_sandbox(app: &mut App, tx: mpsc::UnboundedSender) { annotations: HashMap::new(), workspace: workspace.clone(), await_main_process_attachment: false, + delegated_identity: None, }; let sandbox_name = diff --git a/docs/reference/gateway-config.mdx b/docs/reference/gateway-config.mdx index 32d93aa2e6..ba7a896a1b 100644 --- a/docs/reference/gateway-config.mdx +++ b/docs/reference/gateway-config.mdx @@ -88,6 +88,8 @@ credential_drivers = ["kubernetes-secrets"] sandbox_namespace = "openshell" ssh_session_ttl_secs = 3600 +# Maximum sandbox delegated identity window, in seconds. +max_delegated_identity_duration_secs = 86400 # Reject invalid policy generations securely by default. Set # "retain_last_valid" only when availability takes priority. diff --git a/docs/sandboxes/providers-v2.mdx b/docs/sandboxes/providers-v2.mdx index 7a0f96b5ac..b45a75a701 100644 --- a/docs/sandboxes/providers-v2.mdx +++ b/docs/sandboxes/providers-v2.mdx @@ -526,7 +526,18 @@ openshell provider create \ --runtime-credentials ``` -For `token_exchange` profiles, the provider also stores the user subject token referenced by `token_grant.subject_token.credential`. That credential is gateway-only: the sandbox does not receive it as environment material, static credential binding metadata, or workload placeholder ownership. Create or update that provider credential from the current gateway OIDC login with `--from-oidc-token`. This requires an active named gateway that was registered for OIDC. The CLI copies the current OIDC access token and its expiry into the provider. If the stored gateway access token is expired and a refresh token is available, the CLI refreshes it first. OpenShell does not store the OIDC refresh token in the provider. When the stored subject-token credential expires, the gateway rejects intermediate token exchange until the provider is updated with a fresh token. +For `token_exchange` profiles, choose the subject token source explicitly. +Use `source: provider_credential` when the provider record should hold a subject +credential named by `token_grant.subject_token.credential`. That credential is +gateway-only: the sandbox does not receive it as environment material, static +credential binding metadata, or workload placeholder ownership. Create or update +that provider credential from the current gateway OIDC login with `--from-oidc-token`. +This requires an active named gateway that was registered for OIDC. The CLI +copies the current OIDC access token and its expiry into the provider. If the +stored gateway access token is expired and a refresh token is available, the CLI +refreshes it first. OpenShell does not store the OIDC refresh token in the +provider. When the stored subject-token credential expires, the gateway rejects +intermediate token exchange until the provider is updated with a fresh token. ```shell openshell provider create \ @@ -540,6 +551,56 @@ openshell provider update custom-api \ OpenShell infers the destination credential when the provider profile has exactly one `token_grant.subject_token.credential`. If a profile declares more than one token-exchange subject credential, pass `--credential ` to choose one. +Use `source: sandbox_delegated_identity` when the subject token should be the +creating user's delegated OIDC identity. Create the provider with +`--runtime-credentials`, then create sandboxes with an explicit authorization +window: + +```shell +openshell provider create \ + --name protected-services \ + --type protected-services-profile \ + --runtime-credentials + +openshell sandbox create \ + --provider protected-services \ + --delegate-identity-for=8h +``` + +Delegation must be enabled when the sandbox is created. A sandbox created +without `--delegate-identity-for` cannot add delegated identity later, although +the original delegator can extend or withdraw an existing delegation: + +```shell +openshell sandbox delegated-identity status my-sandbox +openshell sandbox delegated-identity extend my-sandbox --for=24h +openshell sandbox delegated-identity withdraw my-sandbox +``` + +The status command reports `active`, `withdrawn`, `expired`, `revoked`, or +`credential-missing`. `revoked` means the sandbox delegation window still +exists, but the gateway-scoped delegated credential no longer authorizes token +exchange. + +OpenShell stores the delegated refresh token on the gateway and refreshes the +subject access token automatically while the IdP continues to accept that refresh +token. For long-running delegated identity, configure the gateway OIDC client to +issue non-session-bound refresh tokens, such as with `offline_access` when your +IdP supports it. If the IdP rejects refresh with `invalid_grant` or `Session not +active`, re-authenticate locally with `openshell gateway logout` followed by +`openshell gateway login`, then run `openshell sandbox delegated-identity extend` +to replace the gateway's stored delegated credential. + +Platform admins can inspect and revoke the gateway-scoped delegated credential +records: + +```shell +openshell delegated-credential list +openshell delegated-credential status +openshell delegated-credential revoke +openshell delegated-credential delete +``` + Token grant fields: | Field | Required | Behavior | @@ -552,7 +613,7 @@ Token grant fields: | `scopes` | No | OAuth2 scopes sent as a space-separated `scope` parameter. | | `cache_ttl_seconds` | No | Token cache TTL override. When omitted or `0`, OpenShell uses the token response `expires_in` with a 30-second safety margin and one-hour cap, or five minutes minus the margin if the response does not include an expiry. | | `requested_token_type` | No | RFC 8693 `requested_token_type` sent during token exchange. Defaults to `urn:ietf:params:oauth:token-type:access_token`. | -| `subject_token` | Required for `token_exchange` | Subject-token source used for the gateway-brokered intermediate exchange. Phase one supports `source: provider_credential`, where `credential` names another credential declared in the same profile. That referenced credential is broker-only and cannot declare workload injection metadata such as env vars, static placement, refresh, or token grant metadata. | +| `subject_token` | Required for `token_exchange` | Subject-token source used for the gateway-brokered intermediate exchange. Supports `source: provider_credential`, where `credential` names another credential declared in the same profile, and `source: sandbox_delegated_identity`, where the sandbox must have delegated OIDC identity enabled at create time. A provider-credential subject is broker-only and cannot declare workload injection metadata such as env vars, static placement, refresh, or token grant metadata. | | `subject_token.subject_token_type` | No | RFC 8693 `subject_token_type` for the stored subject token. Defaults to `urn:ietf:params:oauth:token-type:access_token`. | | `audience_overrides` | No | Endpoint-specific final-exchange `audience` and `scopes` overrides selected by host, port, and path. These overrides do not affect the gateway intermediate exchange. | diff --git a/proto/openshell.proto b/proto/openshell.proto index 32f39adf67..8824c62ff6 100644 --- a/proto/openshell.proto +++ b/proto/openshell.proto @@ -51,6 +51,36 @@ service OpenShell { }; } + // Fetch delegated identity status for one sandbox. + rpc GetSandboxDelegatedIdentityStatus(GetSandboxDelegatedIdentityStatusRequest) + returns (GetSandboxDelegatedIdentityStatusResponse) { + option (openshell.options.v1.authorization) = { + auth_mode: "bearer" + scope: "sandbox:read" + workspace_role: "user" + }; + } + + // Withdraw delegated identity from one sandbox. + rpc WithdrawSandboxDelegatedIdentity(WithdrawSandboxDelegatedIdentityRequest) + returns (WithdrawSandboxDelegatedIdentityResponse) { + option (openshell.options.v1.authorization) = { + auth_mode: "bearer" + scope: "sandbox:write" + workspace_role: "user" + }; + } + + // Extend delegated identity for one sandbox. + rpc ExtendSandboxDelegatedIdentity(ExtendSandboxDelegatedIdentityRequest) + returns (ExtendSandboxDelegatedIdentityResponse) { + option (openshell.options.v1.authorization) = { + auth_mode: "bearer" + scope: "sandbox:write" + workspace_role: "user" + }; + } + // Fetch a sandbox by name. rpc GetSandbox(GetSandboxRequest) returns (SandboxResponse) { option (openshell.options.v1.authorization) = { @@ -325,6 +355,46 @@ service OpenShell { }; } + // List delegated identity credentials visible to the caller. + rpc ListDelegatedIdentityCredentials(ListDelegatedIdentityCredentialsRequest) + returns (ListDelegatedIdentityCredentialsResponse) { + option (openshell.options.v1.authorization) = { + auth_mode: "bearer" + scope: "provider:read" + global_role: "platform_admin" + }; + } + + // Fetch delegated identity credential status. + rpc GetDelegatedIdentityCredentialStatus(GetDelegatedIdentityCredentialStatusRequest) + returns (GetDelegatedIdentityCredentialStatusResponse) { + option (openshell.options.v1.authorization) = { + auth_mode: "bearer" + scope: "provider:read" + global_role: "platform_admin" + }; + } + + // Revoke a delegated identity credential. + rpc RevokeDelegatedIdentityCredential(RevokeDelegatedIdentityCredentialRequest) + returns (RevokeDelegatedIdentityCredentialResponse) { + option (openshell.options.v1.authorization) = { + auth_mode: "bearer" + scope: "provider:write" + global_role: "platform_admin" + }; + } + + // Delete a delegated identity credential. + rpc DeleteDelegatedIdentityCredential(DeleteDelegatedIdentityCredentialRequest) + returns (DeleteDelegatedIdentityCredentialResponse) { + option (openshell.options.v1.authorization) = { + auth_mode: "bearer" + scope: "provider:write" + global_role: "platform_admin" + }; + } + // Delete gateway-owned refresh configuration for one provider credential. rpc DeleteProviderRefresh(DeleteProviderRefreshRequest) returns (DeleteProviderRefreshResponse) { @@ -814,9 +884,21 @@ message Sandbox { SandboxSpec spec = 2; // Latest user-facing observed status derived by the gateway. SandboxStatus status = 3; + reserved 4, 5, 6; + reserved "phase", "current_policy_version", "delegated_identity"; +} + +message SandboxDelegatedIdentity { + string credential_id = 1; + string principal_subject = 2; + int64 delegated_until_ms = 3; + int64 withdrawn_at_ms = 4; +} - reserved 4, 5; - reserved "phase", "current_policy_version"; +message SandboxDelegatedIdentityRecord { + openshell.datamodel.v1.ObjectMeta metadata = 1; + string sandbox_id = 2; + SandboxDelegatedIdentity delegated_identity = 3; } // Desired sandbox configuration provided through the public API. @@ -983,6 +1065,54 @@ message CreateSandboxRequest { // the canonical main process. The supervisor keeps the terminal transport // alive until that attachment connects and closes naturally. bool await_main_process_attachment = 6; + // Optional gateway-owned delegated identity material. The server persists + // this as a gateway-scoped credential and stores only delegation metadata on + // the sandbox. + DelegatedIdentityRequest delegated_identity = 7; +} + +message DelegatedIdentityRequest { + int64 delegated_until_ms = 1; + string issuer = 2; + string client_id = 3; + string refresh_token = 4 [(openshell.options.v1.secret) = true]; + string access_token = 5 [(openshell.options.v1.secret) = true]; + reserved 6; + reserved "access_token_expires_at_ms"; + string scopes = 7; + string audience = 8; +} + +message GetSandboxDelegatedIdentityStatusRequest { + string name = 1; + string workspace = 2; +} + +message GetSandboxDelegatedIdentityStatusResponse { + SandboxDelegatedIdentity delegated_identity = 1; + int64 now_ms = 2; + int64 credential_revoked_at_ms = 3; + bool credential_missing = 4; +} + +message WithdrawSandboxDelegatedIdentityRequest { + string name = 1; + string workspace = 2; +} + +message WithdrawSandboxDelegatedIdentityResponse { + Sandbox sandbox = 1; + bool withdrawn = 2; +} + +message ExtendSandboxDelegatedIdentityRequest { + string name = 1; + string workspace = 2; + DelegatedIdentityRequest delegated_identity = 3; +} + +message ExtendSandboxDelegatedIdentityResponse { + Sandbox sandbox = 1; } // Get sandbox request. @@ -1717,6 +1847,73 @@ message StoredRefreshMaterialDeletion { openshell.datamodel.v1.CredentialHandle handle = 2; } +message DelegatedIdentityCredential { + openshell.datamodel.v1.ObjectMeta metadata = 1; + string issuer = 2; + string client_id = 3; + string principal_subject = 4; + string refresh_token = 5 [(openshell.options.v1.secret) = true]; + string access_token = 6 [(openshell.options.v1.secret) = true]; + int64 access_token_expires_at_ms = 7; + string scopes = 8; + string audience = 9; + int64 last_refresh_at_ms = 10; + int64 revoked_at_ms = 11; +} + +message DelegatedIdentityCredentialSummary { + openshell.datamodel.v1.ObjectMeta metadata = 1; + string issuer = 2; + string client_id = 3; + string principal_subject = 4; + bool refresh_token_present = 5; + bool access_token_present = 6; + int64 access_token_expires_at_ms = 7; + string scopes = 8; + string audience = 9; + int64 last_refresh_at_ms = 10; + int64 revoked_at_ms = 11; +} + +message ListDelegatedIdentityCredentialsRequest { + uint32 limit = 1; + uint32 offset = 2; +} + +message ListDelegatedIdentityCredentialsResponse { + repeated DelegatedIdentityCredentialSummary credentials = 1; +} + +message GetDelegatedIdentityCredentialStatusRequest { + string id = 1; +} + +message GetDelegatedIdentityCredentialStatusResponse { + DelegatedIdentityCredentialSummary credential = 1; + int64 now_ms = 2; +} + +message RevokeDelegatedIdentityCredentialRequest { + string id = 1; + uint64 expected_resource_version = 2; +} + +message RevokeDelegatedIdentityCredentialResponse { + reserved 1; + bool revoked = 2; + int64 revoked_at_ms = 3; + uint64 resource_version = 4; +} + +message DeleteDelegatedIdentityCredentialRequest { + string id = 1; + uint64 expected_resource_version = 2; +} + +message DeleteDelegatedIdentityCredentialResponse { + bool deleted = 1; +} + message GetProviderRefreshStatusRequest { string provider = 1; string credential_key = 2; diff --git a/sdk/go/proto/openshellv1/openshell.pb.go b/sdk/go/proto/openshellv1/openshell.pb.go index 1b77e0889e..446aa7e2cb 100644 --- a/sdk/go/proto/openshellv1/openshell.pb.go +++ b/sdk/go/proto/openshellv1/openshell.pb.go @@ -1211,6 +1211,134 @@ func (x *Sandbox) GetStatus() *SandboxStatus { return nil } +type SandboxDelegatedIdentity struct { + state protoimpl.MessageState `protogen:"open.v1"` + CredentialId string `protobuf:"bytes,1,opt,name=credential_id,json=credentialId,proto3" json:"credential_id,omitempty"` + PrincipalSubject string `protobuf:"bytes,2,opt,name=principal_subject,json=principalSubject,proto3" json:"principal_subject,omitempty"` + DelegatedUntilMs int64 `protobuf:"varint,3,opt,name=delegated_until_ms,json=delegatedUntilMs,proto3" json:"delegated_until_ms,omitempty"` + WithdrawnAtMs int64 `protobuf:"varint,4,opt,name=withdrawn_at_ms,json=withdrawnAtMs,proto3" json:"withdrawn_at_ms,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SandboxDelegatedIdentity) Reset() { + *x = SandboxDelegatedIdentity{} + mi := &file_openshell_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SandboxDelegatedIdentity) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SandboxDelegatedIdentity) ProtoMessage() {} + +func (x *SandboxDelegatedIdentity) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[13] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SandboxDelegatedIdentity.ProtoReflect.Descriptor instead. +func (*SandboxDelegatedIdentity) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{13} +} + +func (x *SandboxDelegatedIdentity) GetCredentialId() string { + if x != nil { + return x.CredentialId + } + return "" +} + +func (x *SandboxDelegatedIdentity) GetPrincipalSubject() string { + if x != nil { + return x.PrincipalSubject + } + return "" +} + +func (x *SandboxDelegatedIdentity) GetDelegatedUntilMs() int64 { + if x != nil { + return x.DelegatedUntilMs + } + return 0 +} + +func (x *SandboxDelegatedIdentity) GetWithdrawnAtMs() int64 { + if x != nil { + return x.WithdrawnAtMs + } + return 0 +} + +type SandboxDelegatedIdentityRecord struct { + state protoimpl.MessageState `protogen:"open.v1"` + Metadata *datamodelv1.ObjectMeta `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"` + SandboxId string `protobuf:"bytes,2,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` + DelegatedIdentity *SandboxDelegatedIdentity `protobuf:"bytes,3,opt,name=delegated_identity,json=delegatedIdentity,proto3" json:"delegated_identity,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SandboxDelegatedIdentityRecord) Reset() { + *x = SandboxDelegatedIdentityRecord{} + mi := &file_openshell_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SandboxDelegatedIdentityRecord) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SandboxDelegatedIdentityRecord) ProtoMessage() {} + +func (x *SandboxDelegatedIdentityRecord) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[14] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SandboxDelegatedIdentityRecord.ProtoReflect.Descriptor instead. +func (*SandboxDelegatedIdentityRecord) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{14} +} + +func (x *SandboxDelegatedIdentityRecord) GetMetadata() *datamodelv1.ObjectMeta { + if x != nil { + return x.Metadata + } + return nil +} + +func (x *SandboxDelegatedIdentityRecord) GetSandboxId() string { + if x != nil { + return x.SandboxId + } + return "" +} + +func (x *SandboxDelegatedIdentityRecord) GetDelegatedIdentity() *SandboxDelegatedIdentity { + if x != nil { + return x.DelegatedIdentity + } + return nil +} + // Desired sandbox configuration provided through the public API. type SandboxSpec struct { state protoimpl.MessageState `protogen:"open.v1"` @@ -1239,7 +1367,7 @@ type SandboxSpec struct { func (x *SandboxSpec) Reset() { *x = SandboxSpec{} - mi := &file_openshell_proto_msgTypes[13] + mi := &file_openshell_proto_msgTypes[15] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1251,7 +1379,7 @@ func (x *SandboxSpec) String() string { func (*SandboxSpec) ProtoMessage() {} func (x *SandboxSpec) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[13] + mi := &file_openshell_proto_msgTypes[15] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1264,7 +1392,7 @@ func (x *SandboxSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxSpec.ProtoReflect.Descriptor instead. func (*SandboxSpec) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{13} + return file_openshell_proto_rawDescGZIP(), []int{15} } func (x *SandboxSpec) GetLogLevel() string { @@ -1333,7 +1461,7 @@ type ResourceRequirements struct { func (x *ResourceRequirements) Reset() { *x = ResourceRequirements{} - mi := &file_openshell_proto_msgTypes[14] + mi := &file_openshell_proto_msgTypes[16] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1345,7 +1473,7 @@ func (x *ResourceRequirements) String() string { func (*ResourceRequirements) ProtoMessage() {} func (x *ResourceRequirements) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[14] + mi := &file_openshell_proto_msgTypes[16] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1358,7 +1486,7 @@ func (x *ResourceRequirements) ProtoReflect() protoreflect.Message { // Deprecated: Use ResourceRequirements.ProtoReflect.Descriptor instead. func (*ResourceRequirements) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{14} + return file_openshell_proto_rawDescGZIP(), []int{16} } func (x *ResourceRequirements) GetGpu() *GpuResourceRequirements { @@ -1380,7 +1508,7 @@ type GpuResourceRequirements struct { func (x *GpuResourceRequirements) Reset() { *x = GpuResourceRequirements{} - mi := &file_openshell_proto_msgTypes[15] + mi := &file_openshell_proto_msgTypes[17] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1392,7 +1520,7 @@ func (x *GpuResourceRequirements) String() string { func (*GpuResourceRequirements) ProtoMessage() {} func (x *GpuResourceRequirements) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[15] + mi := &file_openshell_proto_msgTypes[17] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1405,7 +1533,7 @@ func (x *GpuResourceRequirements) ProtoReflect() protoreflect.Message { // Deprecated: Use GpuResourceRequirements.ProtoReflect.Descriptor instead. func (*GpuResourceRequirements) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{15} + return file_openshell_proto_rawDescGZIP(), []int{17} } func (x *GpuResourceRequirements) GetCount() uint32 { @@ -1449,7 +1577,7 @@ type SandboxTemplate struct { func (x *SandboxTemplate) Reset() { *x = SandboxTemplate{} - mi := &file_openshell_proto_msgTypes[16] + mi := &file_openshell_proto_msgTypes[18] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1461,7 +1589,7 @@ func (x *SandboxTemplate) String() string { func (*SandboxTemplate) ProtoMessage() {} func (x *SandboxTemplate) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[16] + mi := &file_openshell_proto_msgTypes[18] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1474,7 +1602,7 @@ func (x *SandboxTemplate) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxTemplate.ProtoReflect.Descriptor instead. func (*SandboxTemplate) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{16} + return file_openshell_proto_rawDescGZIP(), []int{18} } func (x *SandboxTemplate) GetImage() string { @@ -1572,7 +1700,7 @@ type SandboxStatus struct { func (x *SandboxStatus) Reset() { *x = SandboxStatus{} - mi := &file_openshell_proto_msgTypes[17] + mi := &file_openshell_proto_msgTypes[19] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1584,7 +1712,7 @@ func (x *SandboxStatus) String() string { func (*SandboxStatus) ProtoMessage() {} func (x *SandboxStatus) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[17] + mi := &file_openshell_proto_msgTypes[19] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1597,7 +1725,7 @@ func (x *SandboxStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxStatus.ProtoReflect.Descriptor instead. func (*SandboxStatus) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{17} + return file_openshell_proto_rawDescGZIP(), []int{19} } func (x *SandboxStatus) GetSandboxName() string { @@ -1682,7 +1810,7 @@ type SandboxCondition struct { func (x *SandboxCondition) Reset() { *x = SandboxCondition{} - mi := &file_openshell_proto_msgTypes[18] + mi := &file_openshell_proto_msgTypes[20] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1694,7 +1822,7 @@ func (x *SandboxCondition) String() string { func (*SandboxCondition) ProtoMessage() {} func (x *SandboxCondition) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[18] + mi := &file_openshell_proto_msgTypes[20] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1707,7 +1835,7 @@ func (x *SandboxCondition) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxCondition.ProtoReflect.Descriptor instead. func (*SandboxCondition) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{18} + return file_openshell_proto_rawDescGZIP(), []int{20} } func (x *SandboxCondition) GetType() string { @@ -1766,7 +1894,7 @@ type PlatformEvent struct { func (x *PlatformEvent) Reset() { *x = PlatformEvent{} - mi := &file_openshell_proto_msgTypes[19] + mi := &file_openshell_proto_msgTypes[21] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1778,7 +1906,7 @@ func (x *PlatformEvent) String() string { func (*PlatformEvent) ProtoMessage() {} func (x *PlatformEvent) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[19] + mi := &file_openshell_proto_msgTypes[21] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1791,7 +1919,7 @@ func (x *PlatformEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use PlatformEvent.ProtoReflect.Descriptor instead. func (*PlatformEvent) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{19} + return file_openshell_proto_rawDescGZIP(), []int{21} } func (x *PlatformEvent) GetTimestampMs() int64 { @@ -1852,13 +1980,17 @@ type CreateSandboxRequest struct { // the canonical main process. The supervisor keeps the terminal transport // alive until that attachment connects and closes naturally. AwaitMainProcessAttachment bool `protobuf:"varint,6,opt,name=await_main_process_attachment,json=awaitMainProcessAttachment,proto3" json:"await_main_process_attachment,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + // Optional gateway-owned delegated identity material. The server persists + // this as a gateway-scoped credential and stores only delegation metadata on + // the sandbox. + DelegatedIdentity *DelegatedIdentityRequest `protobuf:"bytes,7,opt,name=delegated_identity,json=delegatedIdentity,proto3" json:"delegated_identity,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *CreateSandboxRequest) Reset() { *x = CreateSandboxRequest{} - mi := &file_openshell_proto_msgTypes[20] + mi := &file_openshell_proto_msgTypes[22] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1870,7 +2002,7 @@ func (x *CreateSandboxRequest) String() string { func (*CreateSandboxRequest) ProtoMessage() {} func (x *CreateSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[20] + mi := &file_openshell_proto_msgTypes[22] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1883,7 +2015,7 @@ func (x *CreateSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateSandboxRequest.ProtoReflect.Descriptor instead. func (*CreateSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{20} + return file_openshell_proto_rawDescGZIP(), []int{22} } func (x *CreateSandboxRequest) GetSpec() *SandboxSpec { @@ -1928,32 +2060,41 @@ func (x *CreateSandboxRequest) GetAwaitMainProcessAttachment() bool { return false } -// Get sandbox request. -type GetSandboxRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Sandbox name (canonical lookup key). - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - // Workspace scope. Empty defaults to "default". - Workspace string `protobuf:"bytes,2,opt,name=workspace,proto3" json:"workspace,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +func (x *CreateSandboxRequest) GetDelegatedIdentity() *DelegatedIdentityRequest { + if x != nil { + return x.DelegatedIdentity + } + return nil } -func (x *GetSandboxRequest) Reset() { - *x = GetSandboxRequest{} - mi := &file_openshell_proto_msgTypes[21] +type DelegatedIdentityRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + DelegatedUntilMs int64 `protobuf:"varint,1,opt,name=delegated_until_ms,json=delegatedUntilMs,proto3" json:"delegated_until_ms,omitempty"` + Issuer string `protobuf:"bytes,2,opt,name=issuer,proto3" json:"issuer,omitempty"` + ClientId string `protobuf:"bytes,3,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"` + RefreshToken string `protobuf:"bytes,4,opt,name=refresh_token,json=refreshToken,proto3" json:"refresh_token,omitempty"` + AccessToken string `protobuf:"bytes,5,opt,name=access_token,json=accessToken,proto3" json:"access_token,omitempty"` + Scopes string `protobuf:"bytes,7,opt,name=scopes,proto3" json:"scopes,omitempty"` + Audience string `protobuf:"bytes,8,opt,name=audience,proto3" json:"audience,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DelegatedIdentityRequest) Reset() { + *x = DelegatedIdentityRequest{} + mi := &file_openshell_proto_msgTypes[23] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *GetSandboxRequest) String() string { +func (x *DelegatedIdentityRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*GetSandboxRequest) ProtoMessage() {} +func (*DelegatedIdentityRequest) ProtoMessage() {} -func (x *GetSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[21] +func (x *DelegatedIdentityRequest) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[23] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1964,55 +2105,83 @@ func (x *GetSandboxRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use GetSandboxRequest.ProtoReflect.Descriptor instead. -func (*GetSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{21} +// Deprecated: Use DelegatedIdentityRequest.ProtoReflect.Descriptor instead. +func (*DelegatedIdentityRequest) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{23} } -func (x *GetSandboxRequest) GetName() string { +func (x *DelegatedIdentityRequest) GetDelegatedUntilMs() int64 { if x != nil { - return x.Name + return x.DelegatedUntilMs + } + return 0 +} + +func (x *DelegatedIdentityRequest) GetIssuer() string { + if x != nil { + return x.Issuer } return "" } -func (x *GetSandboxRequest) GetWorkspace() string { +func (x *DelegatedIdentityRequest) GetClientId() string { if x != nil { - return x.Workspace + return x.ClientId } return "" } -// List sandboxes request. -type ListSandboxesRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - Limit uint32 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"` - Offset uint32 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"` - // Optional label selector for filtering (format: "key1=value1,key2=value2"). - LabelSelector string `protobuf:"bytes,3,opt,name=label_selector,json=labelSelector,proto3" json:"label_selector,omitempty"` - // Workspace scope. Empty defaults to "default". - Workspace string `protobuf:"bytes,4,opt,name=workspace,proto3" json:"workspace,omitempty"` - // List across all workspaces. Mutually exclusive with workspace. - AllWorkspaces bool `protobuf:"varint,5,opt,name=all_workspaces,json=allWorkspaces,proto3" json:"all_workspaces,omitempty"` +func (x *DelegatedIdentityRequest) GetRefreshToken() string { + if x != nil { + return x.RefreshToken + } + return "" +} + +func (x *DelegatedIdentityRequest) GetAccessToken() string { + if x != nil { + return x.AccessToken + } + return "" +} + +func (x *DelegatedIdentityRequest) GetScopes() string { + if x != nil { + return x.Scopes + } + return "" +} + +func (x *DelegatedIdentityRequest) GetAudience() string { + if x != nil { + return x.Audience + } + return "" +} + +type GetSandboxDelegatedIdentityStatusRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Workspace string `protobuf:"bytes,2,opt,name=workspace,proto3" json:"workspace,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListSandboxesRequest) Reset() { - *x = ListSandboxesRequest{} - mi := &file_openshell_proto_msgTypes[22] +func (x *GetSandboxDelegatedIdentityStatusRequest) Reset() { + *x = GetSandboxDelegatedIdentityStatusRequest{} + mi := &file_openshell_proto_msgTypes[24] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListSandboxesRequest) String() string { +func (x *GetSandboxDelegatedIdentityStatusRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListSandboxesRequest) ProtoMessage() {} +func (*GetSandboxDelegatedIdentityStatusRequest) ProtoMessage() {} -func (x *ListSandboxesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[22] +func (x *GetSandboxDelegatedIdentityStatusRequest) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[24] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2023,72 +2192,50 @@ func (x *ListSandboxesRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListSandboxesRequest.ProtoReflect.Descriptor instead. -func (*ListSandboxesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{22} -} - -func (x *ListSandboxesRequest) GetLimit() uint32 { - if x != nil { - return x.Limit - } - return 0 -} - -func (x *ListSandboxesRequest) GetOffset() uint32 { - if x != nil { - return x.Offset - } - return 0 +// Deprecated: Use GetSandboxDelegatedIdentityStatusRequest.ProtoReflect.Descriptor instead. +func (*GetSandboxDelegatedIdentityStatusRequest) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{24} } -func (x *ListSandboxesRequest) GetLabelSelector() string { +func (x *GetSandboxDelegatedIdentityStatusRequest) GetName() string { if x != nil { - return x.LabelSelector + return x.Name } return "" } -func (x *ListSandboxesRequest) GetWorkspace() string { +func (x *GetSandboxDelegatedIdentityStatusRequest) GetWorkspace() string { if x != nil { return x.Workspace } return "" } -func (x *ListSandboxesRequest) GetAllWorkspaces() bool { - if x != nil { - return x.AllWorkspaces - } - return false +type GetSandboxDelegatedIdentityStatusResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + DelegatedIdentity *SandboxDelegatedIdentity `protobuf:"bytes,1,opt,name=delegated_identity,json=delegatedIdentity,proto3" json:"delegated_identity,omitempty"` + NowMs int64 `protobuf:"varint,2,opt,name=now_ms,json=nowMs,proto3" json:"now_ms,omitempty"` + CredentialRevokedAtMs int64 `protobuf:"varint,3,opt,name=credential_revoked_at_ms,json=credentialRevokedAtMs,proto3" json:"credential_revoked_at_ms,omitempty"` + CredentialMissing bool `protobuf:"varint,4,opt,name=credential_missing,json=credentialMissing,proto3" json:"credential_missing,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -// List providers attached to a sandbox request. -type ListSandboxProvidersRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Sandbox name (canonical lookup key). - SandboxName string `protobuf:"bytes,1,opt,name=sandbox_name,json=sandboxName,proto3" json:"sandbox_name,omitempty"` - // Workspace scope. Empty defaults to "default". - Workspace string `protobuf:"bytes,2,opt,name=workspace,proto3" json:"workspace,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *ListSandboxProvidersRequest) Reset() { - *x = ListSandboxProvidersRequest{} - mi := &file_openshell_proto_msgTypes[23] +func (x *GetSandboxDelegatedIdentityStatusResponse) Reset() { + *x = GetSandboxDelegatedIdentityStatusResponse{} + mi := &file_openshell_proto_msgTypes[25] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListSandboxProvidersRequest) String() string { +func (x *GetSandboxDelegatedIdentityStatusResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListSandboxProvidersRequest) ProtoMessage() {} +func (*GetSandboxDelegatedIdentityStatusResponse) ProtoMessage() {} -func (x *ListSandboxProvidersRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[23] +func (x *GetSandboxDelegatedIdentityStatusResponse) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[25] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2099,58 +2246,62 @@ func (x *ListSandboxProvidersRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListSandboxProvidersRequest.ProtoReflect.Descriptor instead. -func (*ListSandboxProvidersRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{23} +// Deprecated: Use GetSandboxDelegatedIdentityStatusResponse.ProtoReflect.Descriptor instead. +func (*GetSandboxDelegatedIdentityStatusResponse) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{25} } -func (x *ListSandboxProvidersRequest) GetSandboxName() string { +func (x *GetSandboxDelegatedIdentityStatusResponse) GetDelegatedIdentity() *SandboxDelegatedIdentity { if x != nil { - return x.SandboxName + return x.DelegatedIdentity } - return "" + return nil } -func (x *ListSandboxProvidersRequest) GetWorkspace() string { +func (x *GetSandboxDelegatedIdentityStatusResponse) GetNowMs() int64 { if x != nil { - return x.Workspace + return x.NowMs } - return "" + return 0 } -// Attach provider to sandbox request. -type AttachSandboxProviderRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Sandbox name (canonical lookup key). - SandboxName string `protobuf:"bytes,1,opt,name=sandbox_name,json=sandboxName,proto3" json:"sandbox_name,omitempty"` - // Provider name to attach. - ProviderName string `protobuf:"bytes,2,opt,name=provider_name,json=providerName,proto3" json:"provider_name,omitempty"` - // Expected resource version for optimistic concurrency control. - // If 0, the server uses the current version (backward compatibility). - // If non-zero, the server validates that the sandbox's current resource_version - // matches this value before applying the mutation, returning ABORTED on mismatch. - ExpectedResourceVersion uint64 `protobuf:"varint,3,opt,name=expected_resource_version,json=expectedResourceVersion,proto3" json:"expected_resource_version,omitempty"` - // Workspace scope. Empty defaults to "default". - Workspace string `protobuf:"bytes,4,opt,name=workspace,proto3" json:"workspace,omitempty"` +func (x *GetSandboxDelegatedIdentityStatusResponse) GetCredentialRevokedAtMs() int64 { + if x != nil { + return x.CredentialRevokedAtMs + } + return 0 +} + +func (x *GetSandboxDelegatedIdentityStatusResponse) GetCredentialMissing() bool { + if x != nil { + return x.CredentialMissing + } + return false +} + +type WithdrawSandboxDelegatedIdentityRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Workspace string `protobuf:"bytes,2,opt,name=workspace,proto3" json:"workspace,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *AttachSandboxProviderRequest) Reset() { - *x = AttachSandboxProviderRequest{} - mi := &file_openshell_proto_msgTypes[24] +func (x *WithdrawSandboxDelegatedIdentityRequest) Reset() { + *x = WithdrawSandboxDelegatedIdentityRequest{} + mi := &file_openshell_proto_msgTypes[26] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *AttachSandboxProviderRequest) String() string { +func (x *WithdrawSandboxDelegatedIdentityRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*AttachSandboxProviderRequest) ProtoMessage() {} +func (*WithdrawSandboxDelegatedIdentityRequest) ProtoMessage() {} -func (x *AttachSandboxProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[24] +func (x *WithdrawSandboxDelegatedIdentityRequest) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[26] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2161,72 +2312,48 @@ func (x *AttachSandboxProviderRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use AttachSandboxProviderRequest.ProtoReflect.Descriptor instead. -func (*AttachSandboxProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{24} -} - -func (x *AttachSandboxProviderRequest) GetSandboxName() string { - if x != nil { - return x.SandboxName - } - return "" +// Deprecated: Use WithdrawSandboxDelegatedIdentityRequest.ProtoReflect.Descriptor instead. +func (*WithdrawSandboxDelegatedIdentityRequest) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{26} } -func (x *AttachSandboxProviderRequest) GetProviderName() string { +func (x *WithdrawSandboxDelegatedIdentityRequest) GetName() string { if x != nil { - return x.ProviderName + return x.Name } return "" } -func (x *AttachSandboxProviderRequest) GetExpectedResourceVersion() uint64 { - if x != nil { - return x.ExpectedResourceVersion - } - return 0 -} - -func (x *AttachSandboxProviderRequest) GetWorkspace() string { +func (x *WithdrawSandboxDelegatedIdentityRequest) GetWorkspace() string { if x != nil { return x.Workspace } return "" } -// Detach provider from sandbox request. -type DetachSandboxProviderRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Sandbox name (canonical lookup key). - SandboxName string `protobuf:"bytes,1,opt,name=sandbox_name,json=sandboxName,proto3" json:"sandbox_name,omitempty"` - // Provider name to detach. - ProviderName string `protobuf:"bytes,2,opt,name=provider_name,json=providerName,proto3" json:"provider_name,omitempty"` - // Expected resource version for optimistic concurrency control. - // If 0, the server uses the current version (backward compatibility). - // If non-zero, the server validates that the sandbox's current resource_version - // matches this value before applying the mutation, returning ABORTED on mismatch. - ExpectedResourceVersion uint64 `protobuf:"varint,3,opt,name=expected_resource_version,json=expectedResourceVersion,proto3" json:"expected_resource_version,omitempty"` - // Workspace scope. Empty defaults to "default". - Workspace string `protobuf:"bytes,4,opt,name=workspace,proto3" json:"workspace,omitempty"` +type WithdrawSandboxDelegatedIdentityResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Sandbox *Sandbox `protobuf:"bytes,1,opt,name=sandbox,proto3" json:"sandbox,omitempty"` + Withdrawn bool `protobuf:"varint,2,opt,name=withdrawn,proto3" json:"withdrawn,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *DetachSandboxProviderRequest) Reset() { - *x = DetachSandboxProviderRequest{} - mi := &file_openshell_proto_msgTypes[25] +func (x *WithdrawSandboxDelegatedIdentityResponse) Reset() { + *x = WithdrawSandboxDelegatedIdentityResponse{} + mi := &file_openshell_proto_msgTypes[27] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *DetachSandboxProviderRequest) String() string { +func (x *WithdrawSandboxDelegatedIdentityResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*DetachSandboxProviderRequest) ProtoMessage() {} +func (*WithdrawSandboxDelegatedIdentityResponse) ProtoMessage() {} -func (x *DetachSandboxProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[25] +func (x *WithdrawSandboxDelegatedIdentityResponse) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[27] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2237,65 +2364,49 @@ func (x *DetachSandboxProviderRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use DetachSandboxProviderRequest.ProtoReflect.Descriptor instead. -func (*DetachSandboxProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{25} -} - -func (x *DetachSandboxProviderRequest) GetSandboxName() string { - if x != nil { - return x.SandboxName - } - return "" -} - -func (x *DetachSandboxProviderRequest) GetProviderName() string { - if x != nil { - return x.ProviderName - } - return "" +// Deprecated: Use WithdrawSandboxDelegatedIdentityResponse.ProtoReflect.Descriptor instead. +func (*WithdrawSandboxDelegatedIdentityResponse) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{27} } -func (x *DetachSandboxProviderRequest) GetExpectedResourceVersion() uint64 { +func (x *WithdrawSandboxDelegatedIdentityResponse) GetSandbox() *Sandbox { if x != nil { - return x.ExpectedResourceVersion + return x.Sandbox } - return 0 + return nil } -func (x *DetachSandboxProviderRequest) GetWorkspace() string { +func (x *WithdrawSandboxDelegatedIdentityResponse) GetWithdrawn() bool { if x != nil { - return x.Workspace + return x.Withdrawn } - return "" + return false } -// Delete sandbox request. -type DeleteSandboxRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Sandbox name (canonical lookup key). - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - // Workspace scope. Empty defaults to "default". - Workspace string `protobuf:"bytes,2,opt,name=workspace,proto3" json:"workspace,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type ExtendSandboxDelegatedIdentityRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Workspace string `protobuf:"bytes,2,opt,name=workspace,proto3" json:"workspace,omitempty"` + DelegatedIdentity *DelegatedIdentityRequest `protobuf:"bytes,3,opt,name=delegated_identity,json=delegatedIdentity,proto3" json:"delegated_identity,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *DeleteSandboxRequest) Reset() { - *x = DeleteSandboxRequest{} - mi := &file_openshell_proto_msgTypes[26] +func (x *ExtendSandboxDelegatedIdentityRequest) Reset() { + *x = ExtendSandboxDelegatedIdentityRequest{} + mi := &file_openshell_proto_msgTypes[28] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *DeleteSandboxRequest) String() string { +func (x *ExtendSandboxDelegatedIdentityRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*DeleteSandboxRequest) ProtoMessage() {} +func (*ExtendSandboxDelegatedIdentityRequest) ProtoMessage() {} -func (x *DeleteSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[26] +func (x *ExtendSandboxDelegatedIdentityRequest) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[28] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2306,51 +2417,54 @@ func (x *DeleteSandboxRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use DeleteSandboxRequest.ProtoReflect.Descriptor instead. -func (*DeleteSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{26} +// Deprecated: Use ExtendSandboxDelegatedIdentityRequest.ProtoReflect.Descriptor instead. +func (*ExtendSandboxDelegatedIdentityRequest) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{28} } -func (x *DeleteSandboxRequest) GetName() string { +func (x *ExtendSandboxDelegatedIdentityRequest) GetName() string { if x != nil { return x.Name } return "" } -func (x *DeleteSandboxRequest) GetWorkspace() string { +func (x *ExtendSandboxDelegatedIdentityRequest) GetWorkspace() string { if x != nil { return x.Workspace } return "" } -// Stop sandbox request. -type StopSandboxRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Sandbox name (canonical lookup key). - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - // Workspace scope. Empty defaults to "default". - Workspace string `protobuf:"bytes,2,opt,name=workspace,proto3" json:"workspace,omitempty"` +func (x *ExtendSandboxDelegatedIdentityRequest) GetDelegatedIdentity() *DelegatedIdentityRequest { + if x != nil { + return x.DelegatedIdentity + } + return nil +} + +type ExtendSandboxDelegatedIdentityResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Sandbox *Sandbox `protobuf:"bytes,1,opt,name=sandbox,proto3" json:"sandbox,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *StopSandboxRequest) Reset() { - *x = StopSandboxRequest{} - mi := &file_openshell_proto_msgTypes[27] +func (x *ExtendSandboxDelegatedIdentityResponse) Reset() { + *x = ExtendSandboxDelegatedIdentityResponse{} + mi := &file_openshell_proto_msgTypes[29] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *StopSandboxRequest) String() string { +func (x *ExtendSandboxDelegatedIdentityResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*StopSandboxRequest) ProtoMessage() {} +func (*ExtendSandboxDelegatedIdentityResponse) ProtoMessage() {} -func (x *StopSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[27] +func (x *ExtendSandboxDelegatedIdentityResponse) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[29] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2361,27 +2475,20 @@ func (x *StopSandboxRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use StopSandboxRequest.ProtoReflect.Descriptor instead. -func (*StopSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{27} -} - -func (x *StopSandboxRequest) GetName() string { - if x != nil { - return x.Name - } - return "" +// Deprecated: Use ExtendSandboxDelegatedIdentityResponse.ProtoReflect.Descriptor instead. +func (*ExtendSandboxDelegatedIdentityResponse) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{29} } -func (x *StopSandboxRequest) GetWorkspace() string { +func (x *ExtendSandboxDelegatedIdentityResponse) GetSandbox() *Sandbox { if x != nil { - return x.Workspace + return x.Sandbox } - return "" + return nil } -// Start sandbox request. -type StartSandboxRequest struct { +// Get sandbox request. +type GetSandboxRequest struct { state protoimpl.MessageState `protogen:"open.v1"` // Sandbox name (canonical lookup key). Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` @@ -2391,21 +2498,21 @@ type StartSandboxRequest struct { sizeCache protoimpl.SizeCache } -func (x *StartSandboxRequest) Reset() { - *x = StartSandboxRequest{} - mi := &file_openshell_proto_msgTypes[28] +func (x *GetSandboxRequest) Reset() { + *x = GetSandboxRequest{} + mi := &file_openshell_proto_msgTypes[30] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *StartSandboxRequest) String() string { +func (x *GetSandboxRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*StartSandboxRequest) ProtoMessage() {} +func (*GetSandboxRequest) ProtoMessage() {} -func (x *StartSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[28] +func (x *GetSandboxRequest) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[30] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2416,48 +2523,55 @@ func (x *StartSandboxRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use StartSandboxRequest.ProtoReflect.Descriptor instead. -func (*StartSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{28} +// Deprecated: Use GetSandboxRequest.ProtoReflect.Descriptor instead. +func (*GetSandboxRequest) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{30} } -func (x *StartSandboxRequest) GetName() string { +func (x *GetSandboxRequest) GetName() string { if x != nil { return x.Name } return "" } -func (x *StartSandboxRequest) GetWorkspace() string { +func (x *GetSandboxRequest) GetWorkspace() string { if x != nil { return x.Workspace } return "" } -// Sandbox response. -type SandboxResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Sandbox *Sandbox `protobuf:"bytes,1,opt,name=sandbox,proto3" json:"sandbox,omitempty"` +// List sandboxes request. +type ListSandboxesRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Limit uint32 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"` + Offset uint32 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"` + // Optional label selector for filtering (format: "key1=value1,key2=value2"). + LabelSelector string `protobuf:"bytes,3,opt,name=label_selector,json=labelSelector,proto3" json:"label_selector,omitempty"` + // Workspace scope. Empty defaults to "default". + Workspace string `protobuf:"bytes,4,opt,name=workspace,proto3" json:"workspace,omitempty"` + // List across all workspaces. Mutually exclusive with workspace. + AllWorkspaces bool `protobuf:"varint,5,opt,name=all_workspaces,json=allWorkspaces,proto3" json:"all_workspaces,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *SandboxResponse) Reset() { - *x = SandboxResponse{} - mi := &file_openshell_proto_msgTypes[29] +func (x *ListSandboxesRequest) Reset() { + *x = ListSandboxesRequest{} + mi := &file_openshell_proto_msgTypes[31] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *SandboxResponse) String() string { +func (x *ListSandboxesRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*SandboxResponse) ProtoMessage() {} +func (*ListSandboxesRequest) ProtoMessage() {} -func (x *SandboxResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[29] +func (x *ListSandboxesRequest) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[31] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2468,132 +2582,71 @@ func (x *SandboxResponse) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use SandboxResponse.ProtoReflect.Descriptor instead. -func (*SandboxResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{29} +// Deprecated: Use ListSandboxesRequest.ProtoReflect.Descriptor instead. +func (*ListSandboxesRequest) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{31} } -func (x *SandboxResponse) GetSandbox() *Sandbox { +func (x *ListSandboxesRequest) GetLimit() uint32 { if x != nil { - return x.Sandbox + return x.Limit } - return nil -} - -// List sandboxes response. -type ListSandboxesResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Sandboxes []*Sandbox `protobuf:"bytes,1,rep,name=sandboxes,proto3" json:"sandboxes,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *ListSandboxesResponse) Reset() { - *x = ListSandboxesResponse{} - mi := &file_openshell_proto_msgTypes[30] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *ListSandboxesResponse) String() string { - return protoimpl.X.MessageStringOf(x) + return 0 } -func (*ListSandboxesResponse) ProtoMessage() {} - -func (x *ListSandboxesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[30] +func (x *ListSandboxesRequest) GetOffset() uint32 { if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms + return x.Offset } - return mi.MessageOf(x) -} - -// Deprecated: Use ListSandboxesResponse.ProtoReflect.Descriptor instead. -func (*ListSandboxesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{30} + return 0 } -func (x *ListSandboxesResponse) GetSandboxes() []*Sandbox { +func (x *ListSandboxesRequest) GetLabelSelector() string { if x != nil { - return x.Sandboxes + return x.LabelSelector } - return nil -} - -// List providers attached to a sandbox response. -type ListSandboxProvidersResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Providers []*datamodelv1.Provider `protobuf:"bytes,1,rep,name=providers,proto3" json:"providers,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *ListSandboxProvidersResponse) Reset() { - *x = ListSandboxProvidersResponse{} - mi := &file_openshell_proto_msgTypes[31] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *ListSandboxProvidersResponse) String() string { - return protoimpl.X.MessageStringOf(x) + return "" } -func (*ListSandboxProvidersResponse) ProtoMessage() {} - -func (x *ListSandboxProvidersResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[31] +func (x *ListSandboxesRequest) GetWorkspace() string { if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms + return x.Workspace } - return mi.MessageOf(x) -} - -// Deprecated: Use ListSandboxProvidersResponse.ProtoReflect.Descriptor instead. -func (*ListSandboxProvidersResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{31} + return "" } -func (x *ListSandboxProvidersResponse) GetProviders() []*datamodelv1.Provider { +func (x *ListSandboxesRequest) GetAllWorkspaces() bool { if x != nil { - return x.Providers + return x.AllWorkspaces } - return nil + return false } -// Attach provider to sandbox response. -type AttachSandboxProviderResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Sandbox *Sandbox `protobuf:"bytes,1,opt,name=sandbox,proto3" json:"sandbox,omitempty"` - // True when the provider was newly attached. False means it was already attached. - Attached bool `protobuf:"varint,2,opt,name=attached,proto3" json:"attached,omitempty"` +// List providers attached to a sandbox request. +type ListSandboxProvidersRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Sandbox name (canonical lookup key). + SandboxName string `protobuf:"bytes,1,opt,name=sandbox_name,json=sandboxName,proto3" json:"sandbox_name,omitempty"` + // Workspace scope. Empty defaults to "default". + Workspace string `protobuf:"bytes,2,opt,name=workspace,proto3" json:"workspace,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *AttachSandboxProviderResponse) Reset() { - *x = AttachSandboxProviderResponse{} +func (x *ListSandboxProvidersRequest) Reset() { + *x = ListSandboxProvidersRequest{} mi := &file_openshell_proto_msgTypes[32] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *AttachSandboxProviderResponse) String() string { +func (x *ListSandboxProvidersRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*AttachSandboxProviderResponse) ProtoMessage() {} +func (*ListSandboxProvidersRequest) ProtoMessage() {} -func (x *AttachSandboxProviderResponse) ProtoReflect() protoreflect.Message { +func (x *ListSandboxProvidersRequest) ProtoReflect() protoreflect.Message { mi := &file_openshell_proto_msgTypes[32] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -2605,49 +2658,57 @@ func (x *AttachSandboxProviderResponse) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use AttachSandboxProviderResponse.ProtoReflect.Descriptor instead. -func (*AttachSandboxProviderResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use ListSandboxProvidersRequest.ProtoReflect.Descriptor instead. +func (*ListSandboxProvidersRequest) Descriptor() ([]byte, []int) { return file_openshell_proto_rawDescGZIP(), []int{32} } -func (x *AttachSandboxProviderResponse) GetSandbox() *Sandbox { +func (x *ListSandboxProvidersRequest) GetSandboxName() string { if x != nil { - return x.Sandbox + return x.SandboxName } - return nil + return "" } -func (x *AttachSandboxProviderResponse) GetAttached() bool { +func (x *ListSandboxProvidersRequest) GetWorkspace() string { if x != nil { - return x.Attached + return x.Workspace } - return false + return "" } -// Detach provider from sandbox response. -type DetachSandboxProviderResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Sandbox *Sandbox `protobuf:"bytes,1,opt,name=sandbox,proto3" json:"sandbox,omitempty"` - // True when the provider was removed. False means it was not attached. - Detached bool `protobuf:"varint,2,opt,name=detached,proto3" json:"detached,omitempty"` +// Attach provider to sandbox request. +type AttachSandboxProviderRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Sandbox name (canonical lookup key). + SandboxName string `protobuf:"bytes,1,opt,name=sandbox_name,json=sandboxName,proto3" json:"sandbox_name,omitempty"` + // Provider name to attach. + ProviderName string `protobuf:"bytes,2,opt,name=provider_name,json=providerName,proto3" json:"provider_name,omitempty"` + // Expected resource version for optimistic concurrency control. + // If 0, the server uses the current version (backward compatibility). + // If non-zero, the server validates that the sandbox's current resource_version + // matches this value before applying the mutation, returning ABORTED on mismatch. + ExpectedResourceVersion uint64 `protobuf:"varint,3,opt,name=expected_resource_version,json=expectedResourceVersion,proto3" json:"expected_resource_version,omitempty"` + // Workspace scope. Empty defaults to "default". + Workspace string `protobuf:"bytes,4,opt,name=workspace,proto3" json:"workspace,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *DetachSandboxProviderResponse) Reset() { - *x = DetachSandboxProviderResponse{} +func (x *AttachSandboxProviderRequest) Reset() { + *x = AttachSandboxProviderRequest{} mi := &file_openshell_proto_msgTypes[33] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *DetachSandboxProviderResponse) String() string { +func (x *AttachSandboxProviderRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*DetachSandboxProviderResponse) ProtoMessage() {} +func (*AttachSandboxProviderRequest) ProtoMessage() {} -func (x *DetachSandboxProviderResponse) ProtoReflect() protoreflect.Message { +func (x *AttachSandboxProviderRequest) ProtoReflect() protoreflect.Message { mi := &file_openshell_proto_msgTypes[33] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -2659,47 +2720,71 @@ func (x *DetachSandboxProviderResponse) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use DetachSandboxProviderResponse.ProtoReflect.Descriptor instead. -func (*DetachSandboxProviderResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use AttachSandboxProviderRequest.ProtoReflect.Descriptor instead. +func (*AttachSandboxProviderRequest) Descriptor() ([]byte, []int) { return file_openshell_proto_rawDescGZIP(), []int{33} } -func (x *DetachSandboxProviderResponse) GetSandbox() *Sandbox { +func (x *AttachSandboxProviderRequest) GetSandboxName() string { if x != nil { - return x.Sandbox + return x.SandboxName } - return nil + return "" } -func (x *DetachSandboxProviderResponse) GetDetached() bool { +func (x *AttachSandboxProviderRequest) GetProviderName() string { if x != nil { - return x.Detached + return x.ProviderName } - return false + return "" } -// Delete sandbox response. -type DeleteSandboxResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Deleted bool `protobuf:"varint,1,opt,name=deleted,proto3" json:"deleted,omitempty"` +func (x *AttachSandboxProviderRequest) GetExpectedResourceVersion() uint64 { + if x != nil { + return x.ExpectedResourceVersion + } + return 0 +} + +func (x *AttachSandboxProviderRequest) GetWorkspace() string { + if x != nil { + return x.Workspace + } + return "" +} + +// Detach provider from sandbox request. +type DetachSandboxProviderRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Sandbox name (canonical lookup key). + SandboxName string `protobuf:"bytes,1,opt,name=sandbox_name,json=sandboxName,proto3" json:"sandbox_name,omitempty"` + // Provider name to detach. + ProviderName string `protobuf:"bytes,2,opt,name=provider_name,json=providerName,proto3" json:"provider_name,omitempty"` + // Expected resource version for optimistic concurrency control. + // If 0, the server uses the current version (backward compatibility). + // If non-zero, the server validates that the sandbox's current resource_version + // matches this value before applying the mutation, returning ABORTED on mismatch. + ExpectedResourceVersion uint64 `protobuf:"varint,3,opt,name=expected_resource_version,json=expectedResourceVersion,proto3" json:"expected_resource_version,omitempty"` + // Workspace scope. Empty defaults to "default". + Workspace string `protobuf:"bytes,4,opt,name=workspace,proto3" json:"workspace,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *DeleteSandboxResponse) Reset() { - *x = DeleteSandboxResponse{} +func (x *DetachSandboxProviderRequest) Reset() { + *x = DetachSandboxProviderRequest{} mi := &file_openshell_proto_msgTypes[34] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *DeleteSandboxResponse) String() string { +func (x *DetachSandboxProviderRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*DeleteSandboxResponse) ProtoMessage() {} +func (*DetachSandboxProviderRequest) ProtoMessage() {} -func (x *DeleteSandboxResponse) ProtoReflect() protoreflect.Message { +func (x *DetachSandboxProviderRequest) ProtoReflect() protoreflect.Message { mi := &file_openshell_proto_msgTypes[34] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -2711,41 +2796,64 @@ func (x *DeleteSandboxResponse) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use DeleteSandboxResponse.ProtoReflect.Descriptor instead. -func (*DeleteSandboxResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use DetachSandboxProviderRequest.ProtoReflect.Descriptor instead. +func (*DetachSandboxProviderRequest) Descriptor() ([]byte, []int) { return file_openshell_proto_rawDescGZIP(), []int{34} } -func (x *DeleteSandboxResponse) GetDeleted() bool { +func (x *DetachSandboxProviderRequest) GetSandboxName() string { if x != nil { - return x.Deleted + return x.SandboxName } - return false + return "" } -// Create SSH session request. -type CreateSshSessionRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Sandbox id. - SandboxId string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +func (x *DetachSandboxProviderRequest) GetProviderName() string { + if x != nil { + return x.ProviderName + } + return "" } -func (x *CreateSshSessionRequest) Reset() { - *x = CreateSshSessionRequest{} - mi := &file_openshell_proto_msgTypes[35] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) +func (x *DetachSandboxProviderRequest) GetExpectedResourceVersion() uint64 { + if x != nil { + return x.ExpectedResourceVersion + } + return 0 +} + +func (x *DetachSandboxProviderRequest) GetWorkspace() string { + if x != nil { + return x.Workspace + } + return "" +} + +// Delete sandbox request. +type DeleteSandboxRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Sandbox name (canonical lookup key). + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // Workspace scope. Empty defaults to "default". + Workspace string `protobuf:"bytes,2,opt,name=workspace,proto3" json:"workspace,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DeleteSandboxRequest) Reset() { + *x = DeleteSandboxRequest{} + mi := &file_openshell_proto_msgTypes[35] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *CreateSshSessionRequest) String() string { +func (x *DeleteSandboxRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CreateSshSessionRequest) ProtoMessage() {} +func (*DeleteSandboxRequest) ProtoMessage() {} -func (x *CreateSshSessionRequest) ProtoReflect() protoreflect.Message { +func (x *DeleteSandboxRequest) ProtoReflect() protoreflect.Message { mi := &file_openshell_proto_msgTypes[35] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -2757,63 +2865,50 @@ func (x *CreateSshSessionRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CreateSshSessionRequest.ProtoReflect.Descriptor instead. -func (*CreateSshSessionRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use DeleteSandboxRequest.ProtoReflect.Descriptor instead. +func (*DeleteSandboxRequest) Descriptor() ([]byte, []int) { return file_openshell_proto_rawDescGZIP(), []int{35} } -func (x *CreateSshSessionRequest) GetSandboxId() string { +func (x *DeleteSandboxRequest) GetName() string { if x != nil { - return x.SandboxId + return x.Name } return "" } -// Create SSH session response. -// -// Fields are interpolated into an SSH `ProxyCommand` string that OpenSSH -// executes through `/bin/sh -c` on the caller's workstation. Servers MUST -// uphold the charset contract below; clients MUST reject responses that -// violate it. The client's own escaping provides defense-in-depth, but -// narrow charsets close injection vectors at the trust boundary. -type CreateSshSessionResponse struct { +func (x *DeleteSandboxRequest) GetWorkspace() string { + if x != nil { + return x.Workspace + } + return "" +} + +// Stop sandbox request. +type StopSandboxRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // Sandbox id. [A-Za-z0-9._-]{1,128}. - SandboxId string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` - // Session token for the gateway tunnel. URL-safe ASCII - // ([A-Za-z0-9._~+/=-]) up to 4096 bytes. No shell metacharacters or - // whitespace. - Token string `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"` - // Gateway host for SSH proxy connection. IPv4 address, bracketed IPv6 - // address, or DNS hostname (Punycode-encoded for IDN). Alphanumeric plus - // `.-:[]` only, up to 253 bytes. - GatewayHost string `protobuf:"bytes,3,opt,name=gateway_host,json=gatewayHost,proto3" json:"gateway_host,omitempty"` - // Gateway port for SSH proxy connection. Must be in range 1..=65535. - GatewayPort uint32 `protobuf:"varint,4,opt,name=gateway_port,json=gatewayPort,proto3" json:"gateway_port,omitempty"` - // Gateway scheme. Must be exactly "http" or "https". - GatewayScheme string `protobuf:"bytes,5,opt,name=gateway_scheme,json=gatewayScheme,proto3" json:"gateway_scheme,omitempty"` - // Optional host key fingerprint. If non-empty, [A-Za-z0-9:+/=-] only. - HostKeyFingerprint string `protobuf:"bytes,7,opt,name=host_key_fingerprint,json=hostKeyFingerprint,proto3" json:"host_key_fingerprint,omitempty"` - // Expiry timestamp in milliseconds since epoch. 0 means no expiry. - ExpiresAtMs int64 `protobuf:"varint,8,opt,name=expires_at_ms,json=expiresAtMs,proto3" json:"expires_at_ms,omitempty"` + // Sandbox name (canonical lookup key). + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // Workspace scope. Empty defaults to "default". + Workspace string `protobuf:"bytes,2,opt,name=workspace,proto3" json:"workspace,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *CreateSshSessionResponse) Reset() { - *x = CreateSshSessionResponse{} +func (x *StopSandboxRequest) Reset() { + *x = StopSandboxRequest{} mi := &file_openshell_proto_msgTypes[36] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *CreateSshSessionResponse) String() string { +func (x *StopSandboxRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CreateSshSessionResponse) ProtoMessage() {} +func (*StopSandboxRequest) ProtoMessage() {} -func (x *CreateSshSessionResponse) ProtoReflect() protoreflect.Message { +func (x *StopSandboxRequest) ProtoReflect() protoreflect.Message { mi := &file_openshell_proto_msgTypes[36] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -2825,91 +2920,50 @@ func (x *CreateSshSessionResponse) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CreateSshSessionResponse.ProtoReflect.Descriptor instead. -func (*CreateSshSessionResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use StopSandboxRequest.ProtoReflect.Descriptor instead. +func (*StopSandboxRequest) Descriptor() ([]byte, []int) { return file_openshell_proto_rawDescGZIP(), []int{36} } -func (x *CreateSshSessionResponse) GetSandboxId() string { - if x != nil { - return x.SandboxId - } - return "" -} - -func (x *CreateSshSessionResponse) GetToken() string { - if x != nil { - return x.Token - } - return "" -} - -func (x *CreateSshSessionResponse) GetGatewayHost() string { - if x != nil { - return x.GatewayHost - } - return "" -} - -func (x *CreateSshSessionResponse) GetGatewayPort() uint32 { - if x != nil { - return x.GatewayPort - } - return 0 -} - -func (x *CreateSshSessionResponse) GetGatewayScheme() string { +func (x *StopSandboxRequest) GetName() string { if x != nil { - return x.GatewayScheme + return x.Name } return "" } -func (x *CreateSshSessionResponse) GetHostKeyFingerprint() string { +func (x *StopSandboxRequest) GetWorkspace() string { if x != nil { - return x.HostKeyFingerprint + return x.Workspace } return "" } -func (x *CreateSshSessionResponse) GetExpiresAtMs() int64 { - if x != nil { - return x.ExpiresAtMs - } - return 0 -} - -// Request to expose an HTTP service running inside a sandbox. -type ExposeServiceRequest struct { +// Start sandbox request. +type StartSandboxRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // Sandbox name. - Sandbox string `protobuf:"bytes,1,opt,name=sandbox,proto3" json:"sandbox,omitempty"` - // Service name within the sandbox. - Service string `protobuf:"bytes,2,opt,name=service,proto3" json:"service,omitempty"` - // Loopback TCP port inside the sandbox. - TargetPort uint32 `protobuf:"varint,3,opt,name=target_port,json=targetPort,proto3" json:"target_port,omitempty"` - // Whether to print/use the browser-facing service URL. - Domain bool `protobuf:"varint,4,opt,name=domain,proto3" json:"domain,omitempty"` + // Sandbox name (canonical lookup key). + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` // Workspace scope. Empty defaults to "default". - Workspace string `protobuf:"bytes,5,opt,name=workspace,proto3" json:"workspace,omitempty"` + Workspace string `protobuf:"bytes,2,opt,name=workspace,proto3" json:"workspace,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ExposeServiceRequest) Reset() { - *x = ExposeServiceRequest{} +func (x *StartSandboxRequest) Reset() { + *x = StartSandboxRequest{} mi := &file_openshell_proto_msgTypes[37] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ExposeServiceRequest) String() string { +func (x *StartSandboxRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ExposeServiceRequest) ProtoMessage() {} +func (*StartSandboxRequest) ProtoMessage() {} -func (x *ExposeServiceRequest) ProtoReflect() protoreflect.Message { +func (x *StartSandboxRequest) ProtoReflect() protoreflect.Message { mi := &file_openshell_proto_msgTypes[37] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -2921,73 +2975,47 @@ func (x *ExposeServiceRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ExposeServiceRequest.ProtoReflect.Descriptor instead. -func (*ExposeServiceRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use StartSandboxRequest.ProtoReflect.Descriptor instead. +func (*StartSandboxRequest) Descriptor() ([]byte, []int) { return file_openshell_proto_rawDescGZIP(), []int{37} } -func (x *ExposeServiceRequest) GetSandbox() string { - if x != nil { - return x.Sandbox - } - return "" -} - -func (x *ExposeServiceRequest) GetService() string { +func (x *StartSandboxRequest) GetName() string { if x != nil { - return x.Service + return x.Name } return "" } -func (x *ExposeServiceRequest) GetTargetPort() uint32 { - if x != nil { - return x.TargetPort - } - return 0 -} - -func (x *ExposeServiceRequest) GetDomain() bool { - if x != nil { - return x.Domain - } - return false -} - -func (x *ExposeServiceRequest) GetWorkspace() string { +func (x *StartSandboxRequest) GetWorkspace() string { if x != nil { return x.Workspace } return "" } -// Request to fetch an exposed sandbox service endpoint. -type GetServiceRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Sandbox name. - Sandbox string `protobuf:"bytes,1,opt,name=sandbox,proto3" json:"sandbox,omitempty"` - // Service name within the sandbox. Empty selects the unnamed endpoint. - Service string `protobuf:"bytes,2,opt,name=service,proto3" json:"service,omitempty"` - // Workspace scope. Empty defaults to "default". - Workspace string `protobuf:"bytes,3,opt,name=workspace,proto3" json:"workspace,omitempty"` +// Sandbox response. +type SandboxResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Sandbox *Sandbox `protobuf:"bytes,1,opt,name=sandbox,proto3" json:"sandbox,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *GetServiceRequest) Reset() { - *x = GetServiceRequest{} +func (x *SandboxResponse) Reset() { + *x = SandboxResponse{} mi := &file_openshell_proto_msgTypes[38] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *GetServiceRequest) String() string { +func (x *SandboxResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*GetServiceRequest) ProtoMessage() {} +func (*SandboxResponse) ProtoMessage() {} -func (x *GetServiceRequest) ProtoReflect() protoreflect.Message { +func (x *SandboxResponse) ProtoReflect() protoreflect.Message { mi := &file_openshell_proto_msgTypes[38] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -2999,63 +3027,40 @@ func (x *GetServiceRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use GetServiceRequest.ProtoReflect.Descriptor instead. -func (*GetServiceRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use SandboxResponse.ProtoReflect.Descriptor instead. +func (*SandboxResponse) Descriptor() ([]byte, []int) { return file_openshell_proto_rawDescGZIP(), []int{38} } -func (x *GetServiceRequest) GetSandbox() string { +func (x *SandboxResponse) GetSandbox() *Sandbox { if x != nil { return x.Sandbox } - return "" + return nil } -func (x *GetServiceRequest) GetService() string { - if x != nil { - return x.Service - } - return "" +// List sandboxes response. +type ListSandboxesResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Sandboxes []*Sandbox `protobuf:"bytes,1,rep,name=sandboxes,proto3" json:"sandboxes,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *GetServiceRequest) GetWorkspace() string { - if x != nil { - return x.Workspace - } - return "" +func (x *ListSandboxesResponse) Reset() { + *x = ListSandboxesResponse{} + mi := &file_openshell_proto_msgTypes[39] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } -// Request to list exposed sandbox service endpoints. -type ListServicesRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Optional sandbox name. Empty lists endpoints for all sandboxes. - Sandbox string `protobuf:"bytes,1,opt,name=sandbox,proto3" json:"sandbox,omitempty"` - // Page size. Zero uses the server default. - Limit uint32 `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"` - // Page offset. - Offset uint32 `protobuf:"varint,3,opt,name=offset,proto3" json:"offset,omitempty"` - // Workspace scope. Empty defaults to "default". - Workspace string `protobuf:"bytes,4,opt,name=workspace,proto3" json:"workspace,omitempty"` - // List across all workspaces. Mutually exclusive with workspace. - AllWorkspaces bool `protobuf:"varint,5,opt,name=all_workspaces,json=allWorkspaces,proto3" json:"all_workspaces,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *ListServicesRequest) Reset() { - *x = ListServicesRequest{} - mi := &file_openshell_proto_msgTypes[39] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *ListServicesRequest) String() string { +func (x *ListSandboxesResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListServicesRequest) ProtoMessage() {} +func (*ListSandboxesResponse) ProtoMessage() {} -func (x *ListServicesRequest) ProtoReflect() protoreflect.Message { +func (x *ListSandboxesResponse) ProtoReflect() protoreflect.Message { mi := &file_openshell_proto_msgTypes[39] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -3067,68 +3072,40 @@ func (x *ListServicesRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListServicesRequest.ProtoReflect.Descriptor instead. -func (*ListServicesRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use ListSandboxesResponse.ProtoReflect.Descriptor instead. +func (*ListSandboxesResponse) Descriptor() ([]byte, []int) { return file_openshell_proto_rawDescGZIP(), []int{39} } -func (x *ListServicesRequest) GetSandbox() string { - if x != nil { - return x.Sandbox - } - return "" -} - -func (x *ListServicesRequest) GetLimit() uint32 { - if x != nil { - return x.Limit - } - return 0 -} - -func (x *ListServicesRequest) GetOffset() uint32 { - if x != nil { - return x.Offset - } - return 0 -} - -func (x *ListServicesRequest) GetWorkspace() string { - if x != nil { - return x.Workspace - } - return "" -} - -func (x *ListServicesRequest) GetAllWorkspaces() bool { +func (x *ListSandboxesResponse) GetSandboxes() []*Sandbox { if x != nil { - return x.AllWorkspaces + return x.Sandboxes } - return false + return nil } -// Response containing exposed sandbox service endpoints. -type ListServicesResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Services []*ServiceEndpointResponse `protobuf:"bytes,1,rep,name=services,proto3" json:"services,omitempty"` +// List providers attached to a sandbox response. +type ListSandboxProvidersResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Providers []*datamodelv1.Provider `protobuf:"bytes,1,rep,name=providers,proto3" json:"providers,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListServicesResponse) Reset() { - *x = ListServicesResponse{} +func (x *ListSandboxProvidersResponse) Reset() { + *x = ListSandboxProvidersResponse{} mi := &file_openshell_proto_msgTypes[40] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListServicesResponse) String() string { +func (x *ListSandboxProvidersResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListServicesResponse) ProtoMessage() {} +func (*ListSandboxProvidersResponse) ProtoMessage() {} -func (x *ListServicesResponse) ProtoReflect() protoreflect.Message { +func (x *ListSandboxProvidersResponse) ProtoReflect() protoreflect.Message { mi := &file_openshell_proto_msgTypes[40] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -3140,45 +3117,42 @@ func (x *ListServicesResponse) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListServicesResponse.ProtoReflect.Descriptor instead. -func (*ListServicesResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use ListSandboxProvidersResponse.ProtoReflect.Descriptor instead. +func (*ListSandboxProvidersResponse) Descriptor() ([]byte, []int) { return file_openshell_proto_rawDescGZIP(), []int{40} } -func (x *ListServicesResponse) GetServices() []*ServiceEndpointResponse { +func (x *ListSandboxProvidersResponse) GetProviders() []*datamodelv1.Provider { if x != nil { - return x.Services + return x.Providers } return nil } -// Request to delete an exposed sandbox service endpoint. -type DeleteServiceRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Sandbox name. - Sandbox string `protobuf:"bytes,1,opt,name=sandbox,proto3" json:"sandbox,omitempty"` - // Service name within the sandbox. Empty selects the unnamed endpoint. - Service string `protobuf:"bytes,2,opt,name=service,proto3" json:"service,omitempty"` - // Workspace scope. Empty defaults to "default". - Workspace string `protobuf:"bytes,3,opt,name=workspace,proto3" json:"workspace,omitempty"` +// Attach provider to sandbox response. +type AttachSandboxProviderResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Sandbox *Sandbox `protobuf:"bytes,1,opt,name=sandbox,proto3" json:"sandbox,omitempty"` + // True when the provider was newly attached. False means it was already attached. + Attached bool `protobuf:"varint,2,opt,name=attached,proto3" json:"attached,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *DeleteServiceRequest) Reset() { - *x = DeleteServiceRequest{} +func (x *AttachSandboxProviderResponse) Reset() { + *x = AttachSandboxProviderResponse{} mi := &file_openshell_proto_msgTypes[41] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *DeleteServiceRequest) String() string { +func (x *AttachSandboxProviderResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*DeleteServiceRequest) ProtoMessage() {} +func (*AttachSandboxProviderResponse) ProtoMessage() {} -func (x *DeleteServiceRequest) ProtoReflect() protoreflect.Message { +func (x *AttachSandboxProviderResponse) ProtoReflect() protoreflect.Message { mi := &file_openshell_proto_msgTypes[41] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -3190,55 +3164,49 @@ func (x *DeleteServiceRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use DeleteServiceRequest.ProtoReflect.Descriptor instead. -func (*DeleteServiceRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use AttachSandboxProviderResponse.ProtoReflect.Descriptor instead. +func (*AttachSandboxProviderResponse) Descriptor() ([]byte, []int) { return file_openshell_proto_rawDescGZIP(), []int{41} } -func (x *DeleteServiceRequest) GetSandbox() string { +func (x *AttachSandboxProviderResponse) GetSandbox() *Sandbox { if x != nil { return x.Sandbox } - return "" -} - -func (x *DeleteServiceRequest) GetService() string { - if x != nil { - return x.Service - } - return "" + return nil } -func (x *DeleteServiceRequest) GetWorkspace() string { +func (x *AttachSandboxProviderResponse) GetAttached() bool { if x != nil { - return x.Workspace + return x.Attached } - return "" + return false } -// Response for deleting an exposed sandbox service endpoint. -type DeleteServiceResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - // True when an endpoint existed and was deleted. - Deleted bool `protobuf:"varint,1,opt,name=deleted,proto3" json:"deleted,omitempty"` +// Detach provider from sandbox response. +type DetachSandboxProviderResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Sandbox *Sandbox `protobuf:"bytes,1,opt,name=sandbox,proto3" json:"sandbox,omitempty"` + // True when the provider was removed. False means it was not attached. + Detached bool `protobuf:"varint,2,opt,name=detached,proto3" json:"detached,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *DeleteServiceResponse) Reset() { - *x = DeleteServiceResponse{} +func (x *DetachSandboxProviderResponse) Reset() { + *x = DetachSandboxProviderResponse{} mi := &file_openshell_proto_msgTypes[42] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *DeleteServiceResponse) String() string { +func (x *DetachSandboxProviderResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*DeleteServiceResponse) ProtoMessage() {} +func (*DetachSandboxProviderResponse) ProtoMessage() {} -func (x *DeleteServiceResponse) ProtoReflect() protoreflect.Message { +func (x *DetachSandboxProviderResponse) ProtoReflect() protoreflect.Message { mi := &file_openshell_proto_msgTypes[42] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -3250,51 +3218,47 @@ func (x *DeleteServiceResponse) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use DeleteServiceResponse.ProtoReflect.Descriptor instead. -func (*DeleteServiceResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use DetachSandboxProviderResponse.ProtoReflect.Descriptor instead. +func (*DetachSandboxProviderResponse) Descriptor() ([]byte, []int) { return file_openshell_proto_rawDescGZIP(), []int{42} } -func (x *DeleteServiceResponse) GetDeleted() bool { +func (x *DetachSandboxProviderResponse) GetSandbox() *Sandbox { if x != nil { - return x.Deleted + return x.Sandbox + } + return nil +} + +func (x *DetachSandboxProviderResponse) GetDetached() bool { + if x != nil { + return x.Detached } return false } -// Persisted sandbox service endpoint. -type ServiceEndpoint struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Kubernetes-style metadata. - Metadata *datamodelv1.ObjectMeta `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"` - // Sandbox object ID. - SandboxId string `protobuf:"bytes,2,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` - // Sandbox name. - SandboxName string `protobuf:"bytes,3,opt,name=sandbox_name,json=sandboxName,proto3" json:"sandbox_name,omitempty"` - // Service name within the sandbox. - ServiceName string `protobuf:"bytes,4,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"` - // Loopback TCP port inside the sandbox. - TargetPort uint32 `protobuf:"varint,5,opt,name=target_port,json=targetPort,proto3" json:"target_port,omitempty"` - // Whether browser-facing service routing is enabled for this endpoint. - Domain bool `protobuf:"varint,6,opt,name=domain,proto3" json:"domain,omitempty"` +// Delete sandbox response. +type DeleteSandboxResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Deleted bool `protobuf:"varint,1,opt,name=deleted,proto3" json:"deleted,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ServiceEndpoint) Reset() { - *x = ServiceEndpoint{} +func (x *DeleteSandboxResponse) Reset() { + *x = DeleteSandboxResponse{} mi := &file_openshell_proto_msgTypes[43] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ServiceEndpoint) String() string { +func (x *DeleteSandboxResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ServiceEndpoint) ProtoMessage() {} +func (*DeleteSandboxResponse) ProtoMessage() {} -func (x *ServiceEndpoint) ProtoReflect() protoreflect.Message { +func (x *DeleteSandboxResponse) ProtoReflect() protoreflect.Message { mi := &file_openshell_proto_msgTypes[43] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -3306,76 +3270,41 @@ func (x *ServiceEndpoint) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ServiceEndpoint.ProtoReflect.Descriptor instead. -func (*ServiceEndpoint) Descriptor() ([]byte, []int) { +// Deprecated: Use DeleteSandboxResponse.ProtoReflect.Descriptor instead. +func (*DeleteSandboxResponse) Descriptor() ([]byte, []int) { return file_openshell_proto_rawDescGZIP(), []int{43} } -func (x *ServiceEndpoint) GetMetadata() *datamodelv1.ObjectMeta { - if x != nil { - return x.Metadata - } - return nil -} - -func (x *ServiceEndpoint) GetSandboxId() string { - if x != nil { - return x.SandboxId - } - return "" -} - -func (x *ServiceEndpoint) GetSandboxName() string { - if x != nil { - return x.SandboxName - } - return "" -} - -func (x *ServiceEndpoint) GetServiceName() string { - if x != nil { - return x.ServiceName - } - return "" -} - -func (x *ServiceEndpoint) GetTargetPort() uint32 { - if x != nil { - return x.TargetPort - } - return 0 -} - -func (x *ServiceEndpoint) GetDomain() bool { +func (x *DeleteSandboxResponse) GetDeleted() bool { if x != nil { - return x.Domain + return x.Deleted } return false } -// Response containing a service endpoint and, when available, its local URL. -type ServiceEndpointResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Endpoint *ServiceEndpoint `protobuf:"bytes,1,opt,name=endpoint,proto3" json:"endpoint,omitempty"` - Url string `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"` +// Create SSH session request. +type CreateSshSessionRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Sandbox id. + SandboxId string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ServiceEndpointResponse) Reset() { - *x = ServiceEndpointResponse{} +func (x *CreateSshSessionRequest) Reset() { + *x = CreateSshSessionRequest{} mi := &file_openshell_proto_msgTypes[44] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ServiceEndpointResponse) String() string { +func (x *CreateSshSessionRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ServiceEndpointResponse) ProtoMessage() {} +func (*CreateSshSessionRequest) ProtoMessage() {} -func (x *ServiceEndpointResponse) ProtoReflect() protoreflect.Message { +func (x *CreateSshSessionRequest) ProtoReflect() protoreflect.Message { mi := &file_openshell_proto_msgTypes[44] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -3387,48 +3316,63 @@ func (x *ServiceEndpointResponse) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ServiceEndpointResponse.ProtoReflect.Descriptor instead. -func (*ServiceEndpointResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use CreateSshSessionRequest.ProtoReflect.Descriptor instead. +func (*CreateSshSessionRequest) Descriptor() ([]byte, []int) { return file_openshell_proto_rawDescGZIP(), []int{44} } -func (x *ServiceEndpointResponse) GetEndpoint() *ServiceEndpoint { - if x != nil { - return x.Endpoint - } - return nil -} - -func (x *ServiceEndpointResponse) GetUrl() string { +func (x *CreateSshSessionRequest) GetSandboxId() string { if x != nil { - return x.Url + return x.SandboxId } return "" } -// Revoke SSH session request. -type RevokeSshSessionRequest struct { +// Create SSH session response. +// +// Fields are interpolated into an SSH `ProxyCommand` string that OpenSSH +// executes through `/bin/sh -c` on the caller's workstation. Servers MUST +// uphold the charset contract below; clients MUST reject responses that +// violate it. The client's own escaping provides defense-in-depth, but +// narrow charsets close injection vectors at the trust boundary. +type CreateSshSessionResponse struct { state protoimpl.MessageState `protogen:"open.v1"` - // Session token to revoke. - Token string `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"` + // Sandbox id. [A-Za-z0-9._-]{1,128}. + SandboxId string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` + // Session token for the gateway tunnel. URL-safe ASCII + // ([A-Za-z0-9._~+/=-]) up to 4096 bytes. No shell metacharacters or + // whitespace. + Token string `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"` + // Gateway host for SSH proxy connection. IPv4 address, bracketed IPv6 + // address, or DNS hostname (Punycode-encoded for IDN). Alphanumeric plus + // `.-:[]` only, up to 253 bytes. + GatewayHost string `protobuf:"bytes,3,opt,name=gateway_host,json=gatewayHost,proto3" json:"gateway_host,omitempty"` + // Gateway port for SSH proxy connection. Must be in range 1..=65535. + GatewayPort uint32 `protobuf:"varint,4,opt,name=gateway_port,json=gatewayPort,proto3" json:"gateway_port,omitempty"` + // Gateway scheme. Must be exactly "http" or "https". + GatewayScheme string `protobuf:"bytes,5,opt,name=gateway_scheme,json=gatewayScheme,proto3" json:"gateway_scheme,omitempty"` + // Optional host key fingerprint. If non-empty, [A-Za-z0-9:+/=-] only. + HostKeyFingerprint string `protobuf:"bytes,7,opt,name=host_key_fingerprint,json=hostKeyFingerprint,proto3" json:"host_key_fingerprint,omitempty"` + // Expiry timestamp in milliseconds since epoch. 0 means no expiry. + ExpiresAtMs int64 `protobuf:"varint,8,opt,name=expires_at_ms,json=expiresAtMs,proto3" json:"expires_at_ms,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *RevokeSshSessionRequest) Reset() { - *x = RevokeSshSessionRequest{} +func (x *CreateSshSessionResponse) Reset() { + *x = CreateSshSessionResponse{} mi := &file_openshell_proto_msgTypes[45] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *RevokeSshSessionRequest) String() string { +func (x *CreateSshSessionResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RevokeSshSessionRequest) ProtoMessage() {} +func (*CreateSshSessionResponse) ProtoMessage() {} -func (x *RevokeSshSessionRequest) ProtoReflect() protoreflect.Message { +func (x *CreateSshSessionResponse) ProtoReflect() protoreflect.Message { mi := &file_openshell_proto_msgTypes[45] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -3440,104 +3384,92 @@ func (x *RevokeSshSessionRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use RevokeSshSessionRequest.ProtoReflect.Descriptor instead. -func (*RevokeSshSessionRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use CreateSshSessionResponse.ProtoReflect.Descriptor instead. +func (*CreateSshSessionResponse) Descriptor() ([]byte, []int) { return file_openshell_proto_rawDescGZIP(), []int{45} } -func (x *RevokeSshSessionRequest) GetToken() string { +func (x *CreateSshSessionResponse) GetSandboxId() string { if x != nil { - return x.Token + return x.SandboxId } return "" } -// Revoke SSH session response. -type RevokeSshSessionResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - // True when a session was revoked. - Revoked bool `protobuf:"varint,1,opt,name=revoked,proto3" json:"revoked,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +func (x *CreateSshSessionResponse) GetToken() string { + if x != nil { + return x.Token + } + return "" } -func (x *RevokeSshSessionResponse) Reset() { - *x = RevokeSshSessionResponse{} - mi := &file_openshell_proto_msgTypes[46] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) +func (x *CreateSshSessionResponse) GetGatewayHost() string { + if x != nil { + return x.GatewayHost + } + return "" } -func (x *RevokeSshSessionResponse) String() string { - return protoimpl.X.MessageStringOf(x) +func (x *CreateSshSessionResponse) GetGatewayPort() uint32 { + if x != nil { + return x.GatewayPort + } + return 0 } -func (*RevokeSshSessionResponse) ProtoMessage() {} - -func (x *RevokeSshSessionResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[46] +func (x *CreateSshSessionResponse) GetGatewayScheme() string { if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms + return x.GatewayScheme } - return mi.MessageOf(x) + return "" } -// Deprecated: Use RevokeSshSessionResponse.ProtoReflect.Descriptor instead. -func (*RevokeSshSessionResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{46} +func (x *CreateSshSessionResponse) GetHostKeyFingerprint() string { + if x != nil { + return x.HostKeyFingerprint + } + return "" } -func (x *RevokeSshSessionResponse) GetRevoked() bool { +func (x *CreateSshSessionResponse) GetExpiresAtMs() int64 { if x != nil { - return x.Revoked + return x.ExpiresAtMs } - return false + return 0 } -// Execute command request. -type ExecSandboxRequest struct { +// Request to expose an HTTP service running inside a sandbox. +type ExposeServiceRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // Sandbox id. - SandboxId string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` - // Command and arguments. - Command []string `protobuf:"bytes,2,rep,name=command,proto3" json:"command,omitempty"` - // Optional working directory. - Workdir string `protobuf:"bytes,3,opt,name=workdir,proto3" json:"workdir,omitempty"` - // Optional environment overrides. - Environment map[string]string `protobuf:"bytes,4,rep,name=environment,proto3" json:"environment,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - // Optional timeout in seconds. 0 means no timeout. - TimeoutSeconds uint32 `protobuf:"varint,5,opt,name=timeout_seconds,json=timeoutSeconds,proto3" json:"timeout_seconds,omitempty"` - // Optional stdin payload passed to the command. - Stdin []byte `protobuf:"bytes,6,opt,name=stdin,proto3" json:"stdin,omitempty"` - // Request a pseudo-terminal for the remote command. - Tty bool `protobuf:"varint,7,opt,name=tty,proto3" json:"tty,omitempty"` - // Initial terminal columns (used when tty=true, 0 = use default). - Cols uint32 `protobuf:"varint,8,opt,name=cols,proto3" json:"cols,omitempty"` - // Initial terminal rows (used when tty=true, 0 = use default). - Rows uint32 `protobuf:"varint,9,opt,name=rows,proto3" json:"rows,omitempty"` + // Sandbox name. + Sandbox string `protobuf:"bytes,1,opt,name=sandbox,proto3" json:"sandbox,omitempty"` + // Service name within the sandbox. + Service string `protobuf:"bytes,2,opt,name=service,proto3" json:"service,omitempty"` + // Loopback TCP port inside the sandbox. + TargetPort uint32 `protobuf:"varint,3,opt,name=target_port,json=targetPort,proto3" json:"target_port,omitempty"` + // Whether to print/use the browser-facing service URL. + Domain bool `protobuf:"varint,4,opt,name=domain,proto3" json:"domain,omitempty"` + // Workspace scope. Empty defaults to "default". + Workspace string `protobuf:"bytes,5,opt,name=workspace,proto3" json:"workspace,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ExecSandboxRequest) Reset() { - *x = ExecSandboxRequest{} - mi := &file_openshell_proto_msgTypes[47] +func (x *ExposeServiceRequest) Reset() { + *x = ExposeServiceRequest{} + mi := &file_openshell_proto_msgTypes[46] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ExecSandboxRequest) String() string { +func (x *ExposeServiceRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ExecSandboxRequest) ProtoMessage() {} +func (*ExposeServiceRequest) ProtoMessage() {} -func (x *ExecSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[47] +func (x *ExposeServiceRequest) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[46] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3548,97 +3480,74 @@ func (x *ExecSandboxRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ExecSandboxRequest.ProtoReflect.Descriptor instead. -func (*ExecSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{47} +// Deprecated: Use ExposeServiceRequest.ProtoReflect.Descriptor instead. +func (*ExposeServiceRequest) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{46} } -func (x *ExecSandboxRequest) GetSandboxId() string { +func (x *ExposeServiceRequest) GetSandbox() string { if x != nil { - return x.SandboxId + return x.Sandbox } return "" } -func (x *ExecSandboxRequest) GetCommand() []string { - if x != nil { - return x.Command - } - return nil -} - -func (x *ExecSandboxRequest) GetWorkdir() string { +func (x *ExposeServiceRequest) GetService() string { if x != nil { - return x.Workdir + return x.Service } return "" } -func (x *ExecSandboxRequest) GetEnvironment() map[string]string { - if x != nil { - return x.Environment - } - return nil -} - -func (x *ExecSandboxRequest) GetTimeoutSeconds() uint32 { +func (x *ExposeServiceRequest) GetTargetPort() uint32 { if x != nil { - return x.TimeoutSeconds + return x.TargetPort } return 0 } -func (x *ExecSandboxRequest) GetStdin() []byte { - if x != nil { - return x.Stdin - } - return nil -} - -func (x *ExecSandboxRequest) GetTty() bool { +func (x *ExposeServiceRequest) GetDomain() bool { if x != nil { - return x.Tty + return x.Domain } return false } -func (x *ExecSandboxRequest) GetCols() uint32 { - if x != nil { - return x.Cols - } - return 0 -} - -func (x *ExecSandboxRequest) GetRows() uint32 { +func (x *ExposeServiceRequest) GetWorkspace() string { if x != nil { - return x.Rows + return x.Workspace } - return 0 + return "" } -// One stdout chunk from a sandbox exec. -type ExecSandboxStdout struct { - state protoimpl.MessageState `protogen:"open.v1"` - Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` +// Request to fetch an exposed sandbox service endpoint. +type GetServiceRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Sandbox name. + Sandbox string `protobuf:"bytes,1,opt,name=sandbox,proto3" json:"sandbox,omitempty"` + // Service name within the sandbox. Empty selects the unnamed endpoint. + Service string `protobuf:"bytes,2,opt,name=service,proto3" json:"service,omitempty"` + // Workspace scope. Empty defaults to "default". + Workspace string `protobuf:"bytes,3,opt,name=workspace,proto3" json:"workspace,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ExecSandboxStdout) Reset() { - *x = ExecSandboxStdout{} - mi := &file_openshell_proto_msgTypes[48] +func (x *GetServiceRequest) Reset() { + *x = GetServiceRequest{} + mi := &file_openshell_proto_msgTypes[47] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ExecSandboxStdout) String() string { +func (x *GetServiceRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ExecSandboxStdout) ProtoMessage() {} +func (*GetServiceRequest) ProtoMessage() {} -func (x *ExecSandboxStdout) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[48] +func (x *GetServiceRequest) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[47] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3649,41 +3558,64 @@ func (x *ExecSandboxStdout) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ExecSandboxStdout.ProtoReflect.Descriptor instead. -func (*ExecSandboxStdout) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{48} -} +// Deprecated: Use GetServiceRequest.ProtoReflect.Descriptor instead. +func (*GetServiceRequest) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{47} +} -func (x *ExecSandboxStdout) GetData() []byte { +func (x *GetServiceRequest) GetSandbox() string { if x != nil { - return x.Data + return x.Sandbox } - return nil + return "" } -// One stderr chunk from a sandbox exec. -type ExecSandboxStderr struct { - state protoimpl.MessageState `protogen:"open.v1"` - Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` +func (x *GetServiceRequest) GetService() string { + if x != nil { + return x.Service + } + return "" +} + +func (x *GetServiceRequest) GetWorkspace() string { + if x != nil { + return x.Workspace + } + return "" +} + +// Request to list exposed sandbox service endpoints. +type ListServicesRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Optional sandbox name. Empty lists endpoints for all sandboxes. + Sandbox string `protobuf:"bytes,1,opt,name=sandbox,proto3" json:"sandbox,omitempty"` + // Page size. Zero uses the server default. + Limit uint32 `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"` + // Page offset. + Offset uint32 `protobuf:"varint,3,opt,name=offset,proto3" json:"offset,omitempty"` + // Workspace scope. Empty defaults to "default". + Workspace string `protobuf:"bytes,4,opt,name=workspace,proto3" json:"workspace,omitempty"` + // List across all workspaces. Mutually exclusive with workspace. + AllWorkspaces bool `protobuf:"varint,5,opt,name=all_workspaces,json=allWorkspaces,proto3" json:"all_workspaces,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ExecSandboxStderr) Reset() { - *x = ExecSandboxStderr{} - mi := &file_openshell_proto_msgTypes[49] +func (x *ListServicesRequest) Reset() { + *x = ListServicesRequest{} + mi := &file_openshell_proto_msgTypes[48] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ExecSandboxStderr) String() string { +func (x *ListServicesRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ExecSandboxStderr) ProtoMessage() {} +func (*ListServicesRequest) ProtoMessage() {} -func (x *ExecSandboxStderr) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[49] +func (x *ListServicesRequest) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[48] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3694,41 +3626,69 @@ func (x *ExecSandboxStderr) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ExecSandboxStderr.ProtoReflect.Descriptor instead. -func (*ExecSandboxStderr) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{49} +// Deprecated: Use ListServicesRequest.ProtoReflect.Descriptor instead. +func (*ListServicesRequest) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{48} } -func (x *ExecSandboxStderr) GetData() []byte { +func (x *ListServicesRequest) GetSandbox() string { if x != nil { - return x.Data + return x.Sandbox } - return nil + return "" } -// Final exit status for a sandbox exec. -type ExecSandboxExit struct { - state protoimpl.MessageState `protogen:"open.v1"` - ExitCode int32 `protobuf:"varint,1,opt,name=exit_code,json=exitCode,proto3" json:"exit_code,omitempty"` +func (x *ListServicesRequest) GetLimit() uint32 { + if x != nil { + return x.Limit + } + return 0 +} + +func (x *ListServicesRequest) GetOffset() uint32 { + if x != nil { + return x.Offset + } + return 0 +} + +func (x *ListServicesRequest) GetWorkspace() string { + if x != nil { + return x.Workspace + } + return "" +} + +func (x *ListServicesRequest) GetAllWorkspaces() bool { + if x != nil { + return x.AllWorkspaces + } + return false +} + +// Response containing exposed sandbox service endpoints. +type ListServicesResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Services []*ServiceEndpointResponse `protobuf:"bytes,1,rep,name=services,proto3" json:"services,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ExecSandboxExit) Reset() { - *x = ExecSandboxExit{} - mi := &file_openshell_proto_msgTypes[50] +func (x *ListServicesResponse) Reset() { + *x = ListServicesResponse{} + mi := &file_openshell_proto_msgTypes[49] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ExecSandboxExit) String() string { +func (x *ListServicesResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ExecSandboxExit) ProtoMessage() {} +func (*ListServicesResponse) ProtoMessage() {} -func (x *ExecSandboxExit) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[50] +func (x *ListServicesResponse) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[49] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3739,46 +3699,46 @@ func (x *ExecSandboxExit) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ExecSandboxExit.ProtoReflect.Descriptor instead. -func (*ExecSandboxExit) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{50} +// Deprecated: Use ListServicesResponse.ProtoReflect.Descriptor instead. +func (*ListServicesResponse) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{49} } -func (x *ExecSandboxExit) GetExitCode() int32 { +func (x *ListServicesResponse) GetServices() []*ServiceEndpointResponse { if x != nil { - return x.ExitCode + return x.Services } - return 0 + return nil } -// One event in a sandbox exec stream. -type ExecSandboxEvent struct { +// Request to delete an exposed sandbox service endpoint. +type DeleteServiceRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // Types that are valid to be assigned to Payload: - // - // *ExecSandboxEvent_Stdout - // *ExecSandboxEvent_Stderr - // *ExecSandboxEvent_Exit - Payload isExecSandboxEvent_Payload `protobuf_oneof:"payload"` + // Sandbox name. + Sandbox string `protobuf:"bytes,1,opt,name=sandbox,proto3" json:"sandbox,omitempty"` + // Service name within the sandbox. Empty selects the unnamed endpoint. + Service string `protobuf:"bytes,2,opt,name=service,proto3" json:"service,omitempty"` + // Workspace scope. Empty defaults to "default". + Workspace string `protobuf:"bytes,3,opt,name=workspace,proto3" json:"workspace,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ExecSandboxEvent) Reset() { - *x = ExecSandboxEvent{} - mi := &file_openshell_proto_msgTypes[51] +func (x *DeleteServiceRequest) Reset() { + *x = DeleteServiceRequest{} + mi := &file_openshell_proto_msgTypes[50] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ExecSandboxEvent) String() string { +func (x *DeleteServiceRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ExecSandboxEvent) ProtoMessage() {} +func (*DeleteServiceRequest) ProtoMessage() {} -func (x *ExecSandboxEvent) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[51] +func (x *DeleteServiceRequest) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[50] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3789,103 +3749,56 @@ func (x *ExecSandboxEvent) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ExecSandboxEvent.ProtoReflect.Descriptor instead. -func (*ExecSandboxEvent) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{51} -} - -func (x *ExecSandboxEvent) GetPayload() isExecSandboxEvent_Payload { - if x != nil { - return x.Payload - } - return nil +// Deprecated: Use DeleteServiceRequest.ProtoReflect.Descriptor instead. +func (*DeleteServiceRequest) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{50} } -func (x *ExecSandboxEvent) GetStdout() *ExecSandboxStdout { +func (x *DeleteServiceRequest) GetSandbox() string { if x != nil { - if x, ok := x.Payload.(*ExecSandboxEvent_Stdout); ok { - return x.Stdout - } + return x.Sandbox } - return nil + return "" } -func (x *ExecSandboxEvent) GetStderr() *ExecSandboxStderr { +func (x *DeleteServiceRequest) GetService() string { if x != nil { - if x, ok := x.Payload.(*ExecSandboxEvent_Stderr); ok { - return x.Stderr - } + return x.Service } - return nil + return "" } -func (x *ExecSandboxEvent) GetExit() *ExecSandboxExit { +func (x *DeleteServiceRequest) GetWorkspace() string { if x != nil { - if x, ok := x.Payload.(*ExecSandboxEvent_Exit); ok { - return x.Exit - } + return x.Workspace } - return nil -} - -type isExecSandboxEvent_Payload interface { - isExecSandboxEvent_Payload() -} - -type ExecSandboxEvent_Stdout struct { - Stdout *ExecSandboxStdout `protobuf:"bytes,1,opt,name=stdout,proto3,oneof"` -} - -type ExecSandboxEvent_Stderr struct { - Stderr *ExecSandboxStderr `protobuf:"bytes,2,opt,name=stderr,proto3,oneof"` -} - -type ExecSandboxEvent_Exit struct { - Exit *ExecSandboxExit `protobuf:"bytes,3,opt,name=exit,proto3,oneof"` + return "" } -func (*ExecSandboxEvent_Stdout) isExecSandboxEvent_Payload() {} - -func (*ExecSandboxEvent_Stderr) isExecSandboxEvent_Payload() {} - -func (*ExecSandboxEvent_Exit) isExecSandboxEvent_Payload() {} - -// Initial frame for one TCP forward stream. -type TcpForwardInit struct { +// Response for deleting an exposed sandbox service endpoint. +type DeleteServiceResponse struct { state protoimpl.MessageState `protogen:"open.v1"` - // Sandbox id. - SandboxId string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` - // Optional service identifier for audit/correlation. - ServiceId string `protobuf:"bytes,4,opt,name=service_id,json=serviceId,proto3" json:"service_id,omitempty"` - // Target the gateway should request from the supervisor. - // - // Types that are valid to be assigned to Target: - // - // *TcpForwardInit_Ssh - // *TcpForwardInit_Tcp - Target isTcpForwardInit_Target `protobuf_oneof:"target"` - // Optional target-specific authorization token. SSH targets use this as the - // short-lived SSH session token issued by CreateSshSession. - AuthorizationToken string `protobuf:"bytes,7,opt,name=authorization_token,json=authorizationToken,proto3" json:"authorization_token,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + // True when an endpoint existed and was deleted. + Deleted bool `protobuf:"varint,1,opt,name=deleted,proto3" json:"deleted,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *TcpForwardInit) Reset() { - *x = TcpForwardInit{} - mi := &file_openshell_proto_msgTypes[52] +func (x *DeleteServiceResponse) Reset() { + *x = DeleteServiceResponse{} + mi := &file_openshell_proto_msgTypes[51] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *TcpForwardInit) String() string { +func (x *DeleteServiceResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*TcpForwardInit) ProtoMessage() {} +func (*DeleteServiceResponse) ProtoMessage() {} -func (x *TcpForwardInit) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[52] +func (x *DeleteServiceResponse) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[51] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3896,99 +3809,132 @@ func (x *TcpForwardInit) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use TcpForwardInit.ProtoReflect.Descriptor instead. -func (*TcpForwardInit) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{52} +// Deprecated: Use DeleteServiceResponse.ProtoReflect.Descriptor instead. +func (*DeleteServiceResponse) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{51} } -func (x *TcpForwardInit) GetSandboxId() string { +func (x *DeleteServiceResponse) GetDeleted() bool { if x != nil { - return x.SandboxId + return x.Deleted } - return "" + return false } -func (x *TcpForwardInit) GetServiceId() string { - if x != nil { - return x.ServiceId - } - return "" +// Persisted sandbox service endpoint. +type ServiceEndpoint struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Kubernetes-style metadata. + Metadata *datamodelv1.ObjectMeta `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"` + // Sandbox object ID. + SandboxId string `protobuf:"bytes,2,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` + // Sandbox name. + SandboxName string `protobuf:"bytes,3,opt,name=sandbox_name,json=sandboxName,proto3" json:"sandbox_name,omitempty"` + // Service name within the sandbox. + ServiceName string `protobuf:"bytes,4,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"` + // Loopback TCP port inside the sandbox. + TargetPort uint32 `protobuf:"varint,5,opt,name=target_port,json=targetPort,proto3" json:"target_port,omitempty"` + // Whether browser-facing service routing is enabled for this endpoint. + Domain bool `protobuf:"varint,6,opt,name=domain,proto3" json:"domain,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *TcpForwardInit) GetTarget() isTcpForwardInit_Target { - if x != nil { - return x.Target - } - return nil +func (x *ServiceEndpoint) Reset() { + *x = ServiceEndpoint{} + mi := &file_openshell_proto_msgTypes[52] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } -func (x *TcpForwardInit) GetSsh() *SshRelayTarget { +func (x *ServiceEndpoint) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ServiceEndpoint) ProtoMessage() {} + +func (x *ServiceEndpoint) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[52] if x != nil { - if x, ok := x.Target.(*TcpForwardInit_Ssh); ok { - return x.Ssh + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) } + return ms } - return nil + return mi.MessageOf(x) } -func (x *TcpForwardInit) GetTcp() *TcpRelayTarget { +// Deprecated: Use ServiceEndpoint.ProtoReflect.Descriptor instead. +func (*ServiceEndpoint) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{52} +} + +func (x *ServiceEndpoint) GetMetadata() *datamodelv1.ObjectMeta { if x != nil { - if x, ok := x.Target.(*TcpForwardInit_Tcp); ok { - return x.Tcp - } + return x.Metadata } return nil } -func (x *TcpForwardInit) GetAuthorizationToken() string { +func (x *ServiceEndpoint) GetSandboxId() string { if x != nil { - return x.AuthorizationToken + return x.SandboxId } return "" } -type isTcpForwardInit_Target interface { - isTcpForwardInit_Target() +func (x *ServiceEndpoint) GetSandboxName() string { + if x != nil { + return x.SandboxName + } + return "" } -type TcpForwardInit_Ssh struct { - Ssh *SshRelayTarget `protobuf:"bytes,5,opt,name=ssh,proto3,oneof"` +func (x *ServiceEndpoint) GetServiceName() string { + if x != nil { + return x.ServiceName + } + return "" } -type TcpForwardInit_Tcp struct { - Tcp *TcpRelayTarget `protobuf:"bytes,6,opt,name=tcp,proto3,oneof"` +func (x *ServiceEndpoint) GetTargetPort() uint32 { + if x != nil { + return x.TargetPort + } + return 0 } -func (*TcpForwardInit_Ssh) isTcpForwardInit_Target() {} - -func (*TcpForwardInit_Tcp) isTcpForwardInit_Target() {} +func (x *ServiceEndpoint) GetDomain() bool { + if x != nil { + return x.Domain + } + return false +} -// A single frame on the CLI-to-gateway TCP forward stream. -type TcpForwardFrame struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Types that are valid to be assigned to Payload: - // - // *TcpForwardFrame_Init - // *TcpForwardFrame_Data - Payload isTcpForwardFrame_Payload `protobuf_oneof:"payload"` +// Response containing a service endpoint and, when available, its local URL. +type ServiceEndpointResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Endpoint *ServiceEndpoint `protobuf:"bytes,1,opt,name=endpoint,proto3" json:"endpoint,omitempty"` + Url string `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *TcpForwardFrame) Reset() { - *x = TcpForwardFrame{} +func (x *ServiceEndpointResponse) Reset() { + *x = ServiceEndpointResponse{} mi := &file_openshell_proto_msgTypes[53] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *TcpForwardFrame) String() string { +func (x *ServiceEndpointResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*TcpForwardFrame) ProtoMessage() {} +func (*ServiceEndpointResponse) ProtoMessage() {} -func (x *TcpForwardFrame) ProtoReflect() protoreflect.Message { +func (x *ServiceEndpointResponse) ProtoReflect() protoreflect.Message { mi := &file_openshell_proto_msgTypes[53] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -4000,79 +3946,48 @@ func (x *TcpForwardFrame) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use TcpForwardFrame.ProtoReflect.Descriptor instead. -func (*TcpForwardFrame) Descriptor() ([]byte, []int) { +// Deprecated: Use ServiceEndpointResponse.ProtoReflect.Descriptor instead. +func (*ServiceEndpointResponse) Descriptor() ([]byte, []int) { return file_openshell_proto_rawDescGZIP(), []int{53} } -func (x *TcpForwardFrame) GetPayload() isTcpForwardFrame_Payload { - if x != nil { - return x.Payload - } - return nil -} - -func (x *TcpForwardFrame) GetInit() *TcpForwardInit { +func (x *ServiceEndpointResponse) GetEndpoint() *ServiceEndpoint { if x != nil { - if x, ok := x.Payload.(*TcpForwardFrame_Init); ok { - return x.Init - } + return x.Endpoint } return nil } -func (x *TcpForwardFrame) GetData() []byte { +func (x *ServiceEndpointResponse) GetUrl() string { if x != nil { - if x, ok := x.Payload.(*TcpForwardFrame_Data); ok { - return x.Data - } + return x.Url } - return nil -} - -type isTcpForwardFrame_Payload interface { - isTcpForwardFrame_Payload() -} - -type TcpForwardFrame_Init struct { - Init *TcpForwardInit `protobuf:"bytes,1,opt,name=init,proto3,oneof"` -} - -type TcpForwardFrame_Data struct { - Data []byte `protobuf:"bytes,2,opt,name=data,proto3,oneof"` + return "" } -func (*TcpForwardFrame_Init) isTcpForwardFrame_Payload() {} - -func (*TcpForwardFrame_Data) isTcpForwardFrame_Payload() {} - -// Client-to-server message for interactive exec. -type ExecSandboxInput struct { +// Revoke SSH session request. +type RevokeSshSessionRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // Types that are valid to be assigned to Payload: - // - // *ExecSandboxInput_Start - // *ExecSandboxInput_Stdin - // *ExecSandboxInput_Resize - Payload isExecSandboxInput_Payload `protobuf_oneof:"payload"` + // Session token to revoke. + Token string `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ExecSandboxInput) Reset() { - *x = ExecSandboxInput{} +func (x *RevokeSshSessionRequest) Reset() { + *x = RevokeSshSessionRequest{} mi := &file_openshell_proto_msgTypes[54] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ExecSandboxInput) String() string { +func (x *RevokeSshSessionRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ExecSandboxInput) ProtoMessage() {} +func (*RevokeSshSessionRequest) ProtoMessage() {} -func (x *ExecSandboxInput) ProtoReflect() protoreflect.Message { +func (x *RevokeSshSessionRequest) ProtoReflect() protoreflect.Message { mi := &file_openshell_proto_msgTypes[54] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -4084,94 +3999,104 @@ func (x *ExecSandboxInput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ExecSandboxInput.ProtoReflect.Descriptor instead. -func (*ExecSandboxInput) Descriptor() ([]byte, []int) { +// Deprecated: Use RevokeSshSessionRequest.ProtoReflect.Descriptor instead. +func (*RevokeSshSessionRequest) Descriptor() ([]byte, []int) { return file_openshell_proto_rawDescGZIP(), []int{54} } -func (x *ExecSandboxInput) GetPayload() isExecSandboxInput_Payload { +func (x *RevokeSshSessionRequest) GetToken() string { if x != nil { - return x.Payload + return x.Token } - return nil + return "" } -func (x *ExecSandboxInput) GetStart() *ExecSandboxRequest { - if x != nil { - if x, ok := x.Payload.(*ExecSandboxInput_Start); ok { - return x.Start - } - } - return nil +// Revoke SSH session response. +type RevokeSshSessionResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // True when a session was revoked. + Revoked bool `protobuf:"varint,1,opt,name=revoked,proto3" json:"revoked,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *ExecSandboxInput) GetStdin() []byte { - if x != nil { - if x, ok := x.Payload.(*ExecSandboxInput_Stdin); ok { - return x.Stdin - } - } - return nil +func (x *RevokeSshSessionResponse) Reset() { + *x = RevokeSshSessionResponse{} + mi := &file_openshell_proto_msgTypes[55] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } -func (x *ExecSandboxInput) GetResize() *ExecSandboxWindowResize { +func (x *RevokeSshSessionResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RevokeSshSessionResponse) ProtoMessage() {} + +func (x *RevokeSshSessionResponse) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[55] if x != nil { - if x, ok := x.Payload.(*ExecSandboxInput_Resize); ok { - return x.Resize + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) } + return ms } - return nil -} - -type isExecSandboxInput_Payload interface { - isExecSandboxInput_Payload() + return mi.MessageOf(x) } -type ExecSandboxInput_Start struct { - // First message: exec request metadata. - Start *ExecSandboxRequest `protobuf:"bytes,1,opt,name=start,proto3,oneof"` +// Deprecated: Use RevokeSshSessionResponse.ProtoReflect.Descriptor instead. +func (*RevokeSshSessionResponse) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{55} } -type ExecSandboxInput_Stdin struct { - // Subsequent messages: raw stdin bytes. - Stdin []byte `protobuf:"bytes,2,opt,name=stdin,proto3,oneof"` -} - -type ExecSandboxInput_Resize struct { - // Terminal window size change. - Resize *ExecSandboxWindowResize `protobuf:"bytes,3,opt,name=resize,proto3,oneof"` +func (x *RevokeSshSessionResponse) GetRevoked() bool { + if x != nil { + return x.Revoked + } + return false } -func (*ExecSandboxInput_Start) isExecSandboxInput_Payload() {} - -func (*ExecSandboxInput_Stdin) isExecSandboxInput_Payload() {} - -func (*ExecSandboxInput_Resize) isExecSandboxInput_Payload() {} - -// Terminal window resize event for interactive exec. -type ExecSandboxWindowResize struct { - state protoimpl.MessageState `protogen:"open.v1"` - Cols uint32 `protobuf:"varint,1,opt,name=cols,proto3" json:"cols,omitempty"` - Rows uint32 `protobuf:"varint,2,opt,name=rows,proto3" json:"rows,omitempty"` +// Execute command request. +type ExecSandboxRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Sandbox id. + SandboxId string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` + // Command and arguments. + Command []string `protobuf:"bytes,2,rep,name=command,proto3" json:"command,omitempty"` + // Optional working directory. + Workdir string `protobuf:"bytes,3,opt,name=workdir,proto3" json:"workdir,omitempty"` + // Optional environment overrides. + Environment map[string]string `protobuf:"bytes,4,rep,name=environment,proto3" json:"environment,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + // Optional timeout in seconds. 0 means no timeout. + TimeoutSeconds uint32 `protobuf:"varint,5,opt,name=timeout_seconds,json=timeoutSeconds,proto3" json:"timeout_seconds,omitempty"` + // Optional stdin payload passed to the command. + Stdin []byte `protobuf:"bytes,6,opt,name=stdin,proto3" json:"stdin,omitempty"` + // Request a pseudo-terminal for the remote command. + Tty bool `protobuf:"varint,7,opt,name=tty,proto3" json:"tty,omitempty"` + // Initial terminal columns (used when tty=true, 0 = use default). + Cols uint32 `protobuf:"varint,8,opt,name=cols,proto3" json:"cols,omitempty"` + // Initial terminal rows (used when tty=true, 0 = use default). + Rows uint32 `protobuf:"varint,9,opt,name=rows,proto3" json:"rows,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ExecSandboxWindowResize) Reset() { - *x = ExecSandboxWindowResize{} - mi := &file_openshell_proto_msgTypes[55] +func (x *ExecSandboxRequest) Reset() { + *x = ExecSandboxRequest{} + mi := &file_openshell_proto_msgTypes[56] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ExecSandboxWindowResize) String() string { +func (x *ExecSandboxRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ExecSandboxWindowResize) ProtoMessage() {} +func (*ExecSandboxRequest) ProtoMessage() {} -func (x *ExecSandboxWindowResize) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[55] +func (x *ExecSandboxRequest) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[56] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4182,151 +4107,96 @@ func (x *ExecSandboxWindowResize) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ExecSandboxWindowResize.ProtoReflect.Descriptor instead. -func (*ExecSandboxWindowResize) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{55} +// Deprecated: Use ExecSandboxRequest.ProtoReflect.Descriptor instead. +func (*ExecSandboxRequest) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{56} } -func (x *ExecSandboxWindowResize) GetCols() uint32 { +func (x *ExecSandboxRequest) GetSandboxId() string { if x != nil { - return x.Cols + return x.SandboxId } - return 0 + return "" } -func (x *ExecSandboxWindowResize) GetRows() uint32 { +func (x *ExecSandboxRequest) GetCommand() []string { if x != nil { - return x.Rows + return x.Command } - return 0 -} - -// SSH session record stored in persistence. -type SshSession struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Kubernetes-style metadata (id, name, labels, timestamps, resource version). - Metadata *datamodelv1.ObjectMeta `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"` - // Sandbox id. - SandboxId string `protobuf:"bytes,2,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` - // Session token. - Token string `protobuf:"bytes,3,opt,name=token,proto3" json:"token,omitempty"` - // Expiry timestamp in milliseconds since epoch. 0 means no expiry - // (backward-compatible default for sessions created before this field existed). - ExpiresAtMs int64 `protobuf:"varint,4,opt,name=expires_at_ms,json=expiresAtMs,proto3" json:"expires_at_ms,omitempty"` - // Revoked flag. - Revoked bool `protobuf:"varint,5,opt,name=revoked,proto3" json:"revoked,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SshSession) Reset() { - *x = SshSession{} - mi := &file_openshell_proto_msgTypes[56] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SshSession) String() string { - return protoimpl.X.MessageStringOf(x) + return nil } -func (*SshSession) ProtoMessage() {} - -func (x *SshSession) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[56] +func (x *ExecSandboxRequest) GetWorkdir() string { if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms + return x.Workdir } - return mi.MessageOf(x) + return "" } -// Deprecated: Use SshSession.ProtoReflect.Descriptor instead. -func (*SshSession) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{56} +func (x *ExecSandboxRequest) GetEnvironment() map[string]string { + if x != nil { + return x.Environment + } + return nil } -func (x *SshSession) GetMetadata() *datamodelv1.ObjectMeta { +func (x *ExecSandboxRequest) GetTimeoutSeconds() uint32 { if x != nil { - return x.Metadata + return x.TimeoutSeconds } - return nil + return 0 } -func (x *SshSession) GetSandboxId() string { +func (x *ExecSandboxRequest) GetStdin() []byte { if x != nil { - return x.SandboxId + return x.Stdin } - return "" + return nil } -func (x *SshSession) GetToken() string { +func (x *ExecSandboxRequest) GetTty() bool { if x != nil { - return x.Token + return x.Tty } - return "" + return false } -func (x *SshSession) GetExpiresAtMs() int64 { +func (x *ExecSandboxRequest) GetCols() uint32 { if x != nil { - return x.ExpiresAtMs + return x.Cols } return 0 } -func (x *SshSession) GetRevoked() bool { +func (x *ExecSandboxRequest) GetRows() uint32 { if x != nil { - return x.Revoked + return x.Rows } - return false + return 0 } -// Watch sandbox request. -type WatchSandboxRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Sandbox id. - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - // Stream sandbox status snapshots. - FollowStatus bool `protobuf:"varint,2,opt,name=follow_status,json=followStatus,proto3" json:"follow_status,omitempty"` - // Stream openshell-server process logs correlated to this sandbox. - FollowLogs bool `protobuf:"varint,3,opt,name=follow_logs,json=followLogs,proto3" json:"follow_logs,omitempty"` - // Stream platform events correlated to this sandbox. - FollowEvents bool `protobuf:"varint,4,opt,name=follow_events,json=followEvents,proto3" json:"follow_events,omitempty"` - // Replay the last N log lines (best-effort) before following. - LogTailLines uint32 `protobuf:"varint,5,opt,name=log_tail_lines,json=logTailLines,proto3" json:"log_tail_lines,omitempty"` - // Replay the last N platform events (best-effort) before following. - EventTail uint32 `protobuf:"varint,6,opt,name=event_tail,json=eventTail,proto3" json:"event_tail,omitempty"` - // Stop streaming once the sandbox reaches READY or a terminal result phase - // (COMPLETED, STOPPED, or ERROR). - StopOnTerminal bool `protobuf:"varint,7,opt,name=stop_on_terminal,json=stopOnTerminal,proto3" json:"stop_on_terminal,omitempty"` - // Only include log lines with timestamp >= this value (milliseconds since epoch). - // 0 means no time filter. Applies to both tail replay and live streaming. - LogSinceMs int64 `protobuf:"varint,8,opt,name=log_since_ms,json=logSinceMs,proto3" json:"log_since_ms,omitempty"` - // Filter by log source (e.g. "gateway", "sandbox"). Empty means all sources. - LogSources []string `protobuf:"bytes,9,rep,name=log_sources,json=logSources,proto3" json:"log_sources,omitempty"` - // Minimum log level to include (e.g. "INFO", "WARN", "ERROR"). Empty means all levels. - LogMinLevel string `protobuf:"bytes,10,opt,name=log_min_level,json=logMinLevel,proto3" json:"log_min_level,omitempty"` +// One stdout chunk from a sandbox exec. +type ExecSandboxStdout struct { + state protoimpl.MessageState `protogen:"open.v1"` + Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *WatchSandboxRequest) Reset() { - *x = WatchSandboxRequest{} +func (x *ExecSandboxStdout) Reset() { + *x = ExecSandboxStdout{} mi := &file_openshell_proto_msgTypes[57] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *WatchSandboxRequest) String() string { +func (x *ExecSandboxStdout) String() string { return protoimpl.X.MessageStringOf(x) } -func (*WatchSandboxRequest) ProtoMessage() {} +func (*ExecSandboxStdout) ProtoMessage() {} -func (x *WatchSandboxRequest) ProtoReflect() protoreflect.Message { +func (x *ExecSandboxStdout) ProtoReflect() protoreflect.Message { mi := &file_openshell_proto_msgTypes[57] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -4338,111 +4208,136 @@ func (x *WatchSandboxRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use WatchSandboxRequest.ProtoReflect.Descriptor instead. -func (*WatchSandboxRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use ExecSandboxStdout.ProtoReflect.Descriptor instead. +func (*ExecSandboxStdout) Descriptor() ([]byte, []int) { return file_openshell_proto_rawDescGZIP(), []int{57} } -func (x *WatchSandboxRequest) GetId() string { +func (x *ExecSandboxStdout) GetData() []byte { if x != nil { - return x.Id + return x.Data } - return "" + return nil } -func (x *WatchSandboxRequest) GetFollowStatus() bool { - if x != nil { - return x.FollowStatus - } - return false +// One stderr chunk from a sandbox exec. +type ExecSandboxStderr struct { + state protoimpl.MessageState `protogen:"open.v1"` + Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *WatchSandboxRequest) GetFollowLogs() bool { - if x != nil { - return x.FollowLogs - } - return false +func (x *ExecSandboxStderr) Reset() { + *x = ExecSandboxStderr{} + mi := &file_openshell_proto_msgTypes[58] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } -func (x *WatchSandboxRequest) GetFollowEvents() bool { - if x != nil { - return x.FollowEvents - } - return false +func (x *ExecSandboxStderr) String() string { + return protoimpl.X.MessageStringOf(x) } -func (x *WatchSandboxRequest) GetLogTailLines() uint32 { +func (*ExecSandboxStderr) ProtoMessage() {} + +func (x *ExecSandboxStderr) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[58] if x != nil { - return x.LogTailLines + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return 0 + return mi.MessageOf(x) } -func (x *WatchSandboxRequest) GetEventTail() uint32 { - if x != nil { - return x.EventTail - } - return 0 +// Deprecated: Use ExecSandboxStderr.ProtoReflect.Descriptor instead. +func (*ExecSandboxStderr) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{58} } -func (x *WatchSandboxRequest) GetStopOnTerminal() bool { +func (x *ExecSandboxStderr) GetData() []byte { if x != nil { - return x.StopOnTerminal + return x.Data } - return false + return nil } -func (x *WatchSandboxRequest) GetLogSinceMs() int64 { - if x != nil { - return x.LogSinceMs - } - return 0 +// Final exit status for a sandbox exec. +type ExecSandboxExit struct { + state protoimpl.MessageState `protogen:"open.v1"` + ExitCode int32 `protobuf:"varint,1,opt,name=exit_code,json=exitCode,proto3" json:"exit_code,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *WatchSandboxRequest) GetLogSources() []string { +func (x *ExecSandboxExit) Reset() { + *x = ExecSandboxExit{} + mi := &file_openshell_proto_msgTypes[59] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ExecSandboxExit) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ExecSandboxExit) ProtoMessage() {} + +func (x *ExecSandboxExit) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[59] if x != nil { - return x.LogSources + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return nil + return mi.MessageOf(x) } -func (x *WatchSandboxRequest) GetLogMinLevel() string { +// Deprecated: Use ExecSandboxExit.ProtoReflect.Descriptor instead. +func (*ExecSandboxExit) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{59} +} + +func (x *ExecSandboxExit) GetExitCode() int32 { if x != nil { - return x.LogMinLevel + return x.ExitCode } - return "" + return 0 } -// One event in a sandbox watch stream. -type SandboxStreamEvent struct { +// One event in a sandbox exec stream. +type ExecSandboxEvent struct { state protoimpl.MessageState `protogen:"open.v1"` // Types that are valid to be assigned to Payload: // - // *SandboxStreamEvent_Sandbox - // *SandboxStreamEvent_Log - // *SandboxStreamEvent_Event - // *SandboxStreamEvent_Warning - // *SandboxStreamEvent_DraftPolicyUpdate - Payload isSandboxStreamEvent_Payload `protobuf_oneof:"payload"` + // *ExecSandboxEvent_Stdout + // *ExecSandboxEvent_Stderr + // *ExecSandboxEvent_Exit + Payload isExecSandboxEvent_Payload `protobuf_oneof:"payload"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *SandboxStreamEvent) Reset() { - *x = SandboxStreamEvent{} - mi := &file_openshell_proto_msgTypes[58] +func (x *ExecSandboxEvent) Reset() { + *x = ExecSandboxEvent{} + mi := &file_openshell_proto_msgTypes[60] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *SandboxStreamEvent) String() string { +func (x *ExecSandboxEvent) String() string { return protoimpl.X.MessageStringOf(x) } -func (*SandboxStreamEvent) ProtoMessage() {} +func (*ExecSandboxEvent) ProtoMessage() {} -func (x *SandboxStreamEvent) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[58] +func (x *ExecSandboxEvent) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[60] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4453,134 +4348,103 @@ func (x *SandboxStreamEvent) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use SandboxStreamEvent.ProtoReflect.Descriptor instead. -func (*SandboxStreamEvent) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{58} +// Deprecated: Use ExecSandboxEvent.ProtoReflect.Descriptor instead. +func (*ExecSandboxEvent) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{60} } -func (x *SandboxStreamEvent) GetPayload() isSandboxStreamEvent_Payload { +func (x *ExecSandboxEvent) GetPayload() isExecSandboxEvent_Payload { if x != nil { return x.Payload } return nil } -func (x *SandboxStreamEvent) GetSandbox() *Sandbox { - if x != nil { - if x, ok := x.Payload.(*SandboxStreamEvent_Sandbox); ok { - return x.Sandbox - } - } - return nil -} - -func (x *SandboxStreamEvent) GetLog() *SandboxLogLine { - if x != nil { - if x, ok := x.Payload.(*SandboxStreamEvent_Log); ok { - return x.Log - } - } - return nil -} - -func (x *SandboxStreamEvent) GetEvent() *PlatformEvent { +func (x *ExecSandboxEvent) GetStdout() *ExecSandboxStdout { if x != nil { - if x, ok := x.Payload.(*SandboxStreamEvent_Event); ok { - return x.Event + if x, ok := x.Payload.(*ExecSandboxEvent_Stdout); ok { + return x.Stdout } } return nil } -func (x *SandboxStreamEvent) GetWarning() *SandboxStreamWarning { +func (x *ExecSandboxEvent) GetStderr() *ExecSandboxStderr { if x != nil { - if x, ok := x.Payload.(*SandboxStreamEvent_Warning); ok { - return x.Warning + if x, ok := x.Payload.(*ExecSandboxEvent_Stderr); ok { + return x.Stderr } } return nil } -func (x *SandboxStreamEvent) GetDraftPolicyUpdate() *DraftPolicyUpdate { +func (x *ExecSandboxEvent) GetExit() *ExecSandboxExit { if x != nil { - if x, ok := x.Payload.(*SandboxStreamEvent_DraftPolicyUpdate); ok { - return x.DraftPolicyUpdate + if x, ok := x.Payload.(*ExecSandboxEvent_Exit); ok { + return x.Exit } } return nil } -type isSandboxStreamEvent_Payload interface { - isSandboxStreamEvent_Payload() -} - -type SandboxStreamEvent_Sandbox struct { - // Latest sandbox snapshot. - Sandbox *Sandbox `protobuf:"bytes,1,opt,name=sandbox,proto3,oneof"` -} - -type SandboxStreamEvent_Log struct { - // One server log line/event. - Log *SandboxLogLine `protobuf:"bytes,2,opt,name=log,proto3,oneof"` +type isExecSandboxEvent_Payload interface { + isExecSandboxEvent_Payload() } -type SandboxStreamEvent_Event struct { - // One platform event. - Event *PlatformEvent `protobuf:"bytes,3,opt,name=event,proto3,oneof"` +type ExecSandboxEvent_Stdout struct { + Stdout *ExecSandboxStdout `protobuf:"bytes,1,opt,name=stdout,proto3,oneof"` } -type SandboxStreamEvent_Warning struct { - // Warning from the server (e.g. missed messages due to lag). - Warning *SandboxStreamWarning `protobuf:"bytes,4,opt,name=warning,proto3,oneof"` +type ExecSandboxEvent_Stderr struct { + Stderr *ExecSandboxStderr `protobuf:"bytes,2,opt,name=stderr,proto3,oneof"` } -type SandboxStreamEvent_DraftPolicyUpdate struct { - // Draft policy update notification. - DraftPolicyUpdate *DraftPolicyUpdate `protobuf:"bytes,5,opt,name=draft_policy_update,json=draftPolicyUpdate,proto3,oneof"` +type ExecSandboxEvent_Exit struct { + Exit *ExecSandboxExit `protobuf:"bytes,3,opt,name=exit,proto3,oneof"` } -func (*SandboxStreamEvent_Sandbox) isSandboxStreamEvent_Payload() {} - -func (*SandboxStreamEvent_Log) isSandboxStreamEvent_Payload() {} - -func (*SandboxStreamEvent_Event) isSandboxStreamEvent_Payload() {} +func (*ExecSandboxEvent_Stdout) isExecSandboxEvent_Payload() {} -func (*SandboxStreamEvent_Warning) isSandboxStreamEvent_Payload() {} +func (*ExecSandboxEvent_Stderr) isExecSandboxEvent_Payload() {} -func (*SandboxStreamEvent_DraftPolicyUpdate) isSandboxStreamEvent_Payload() {} +func (*ExecSandboxEvent_Exit) isExecSandboxEvent_Payload() {} -// Log line correlated to a sandbox. -type SandboxLogLine struct { - state protoimpl.MessageState `protogen:"open.v1"` - SandboxId string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` - TimestampMs int64 `protobuf:"varint,2,opt,name=timestamp_ms,json=timestampMs,proto3" json:"timestamp_ms,omitempty"` - Level string `protobuf:"bytes,3,opt,name=level,proto3" json:"level,omitempty"` - Target string `protobuf:"bytes,4,opt,name=target,proto3" json:"target,omitempty"` - Message string `protobuf:"bytes,5,opt,name=message,proto3" json:"message,omitempty"` - // Log source: "gateway" (server-side) or "sandbox" (supervisor). - // Empty is treated as "gateway" for backward compatibility. - Source string `protobuf:"bytes,6,opt,name=source,proto3" json:"source,omitempty"` - // Structured key-value fields from the tracing event (e.g. dst_host, action). - Fields map[string]string `protobuf:"bytes,7,rep,name=fields,proto3" json:"fields,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +// Initial frame for one TCP forward stream. +type TcpForwardInit struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Sandbox id. + SandboxId string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` + // Optional service identifier for audit/correlation. + ServiceId string `protobuf:"bytes,4,opt,name=service_id,json=serviceId,proto3" json:"service_id,omitempty"` + // Target the gateway should request from the supervisor. + // + // Types that are valid to be assigned to Target: + // + // *TcpForwardInit_Ssh + // *TcpForwardInit_Tcp + Target isTcpForwardInit_Target `protobuf_oneof:"target"` + // Optional target-specific authorization token. SSH targets use this as the + // short-lived SSH session token issued by CreateSshSession. + AuthorizationToken string `protobuf:"bytes,7,opt,name=authorization_token,json=authorizationToken,proto3" json:"authorization_token,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *SandboxLogLine) Reset() { - *x = SandboxLogLine{} - mi := &file_openshell_proto_msgTypes[59] +func (x *TcpForwardInit) Reset() { + *x = TcpForwardInit{} + mi := &file_openshell_proto_msgTypes[61] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *SandboxLogLine) String() string { +func (x *TcpForwardInit) String() string { return protoimpl.X.MessageStringOf(x) } -func (*SandboxLogLine) ProtoMessage() {} +func (*TcpForwardInit) ProtoMessage() {} -func (x *SandboxLogLine) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[59] +func (x *TcpForwardInit) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[61] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4591,129 +4455,100 @@ func (x *SandboxLogLine) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use SandboxLogLine.ProtoReflect.Descriptor instead. -func (*SandboxLogLine) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{59} +// Deprecated: Use TcpForwardInit.ProtoReflect.Descriptor instead. +func (*TcpForwardInit) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{61} } -func (x *SandboxLogLine) GetSandboxId() string { +func (x *TcpForwardInit) GetSandboxId() string { if x != nil { return x.SandboxId } return "" } -func (x *SandboxLogLine) GetTimestampMs() int64 { +func (x *TcpForwardInit) GetServiceId() string { if x != nil { - return x.TimestampMs + return x.ServiceId } - return 0 + return "" } -func (x *SandboxLogLine) GetLevel() string { +func (x *TcpForwardInit) GetTarget() isTcpForwardInit_Target { if x != nil { - return x.Level + return x.Target } - return "" + return nil } -func (x *SandboxLogLine) GetTarget() string { +func (x *TcpForwardInit) GetSsh() *SshRelayTarget { if x != nil { - return x.Target + if x, ok := x.Target.(*TcpForwardInit_Ssh); ok { + return x.Ssh + } } - return "" + return nil } -func (x *SandboxLogLine) GetMessage() string { +func (x *TcpForwardInit) GetTcp() *TcpRelayTarget { if x != nil { - return x.Message + if x, ok := x.Target.(*TcpForwardInit_Tcp); ok { + return x.Tcp + } } - return "" + return nil } -func (x *SandboxLogLine) GetSource() string { +func (x *TcpForwardInit) GetAuthorizationToken() string { if x != nil { - return x.Source + return x.AuthorizationToken } return "" } -func (x *SandboxLogLine) GetFields() map[string]string { - if x != nil { - return x.Fields - } - return nil +type isTcpForwardInit_Target interface { + isTcpForwardInit_Target() } -type SandboxStreamWarning struct { - state protoimpl.MessageState `protogen:"open.v1"` - Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *SandboxStreamWarning) Reset() { - *x = SandboxStreamWarning{} - mi := &file_openshell_proto_msgTypes[60] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *SandboxStreamWarning) String() string { - return protoimpl.X.MessageStringOf(x) +type TcpForwardInit_Ssh struct { + Ssh *SshRelayTarget `protobuf:"bytes,5,opt,name=ssh,proto3,oneof"` } -func (*SandboxStreamWarning) ProtoMessage() {} - -func (x *SandboxStreamWarning) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[60] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) +type TcpForwardInit_Tcp struct { + Tcp *TcpRelayTarget `protobuf:"bytes,6,opt,name=tcp,proto3,oneof"` } -// Deprecated: Use SandboxStreamWarning.ProtoReflect.Descriptor instead. -func (*SandboxStreamWarning) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{60} -} +func (*TcpForwardInit_Ssh) isTcpForwardInit_Target() {} -func (x *SandboxStreamWarning) GetMessage() string { - if x != nil { - return x.Message - } - return "" -} +func (*TcpForwardInit_Tcp) isTcpForwardInit_Target() {} -// Create provider request. -type CreateProviderRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - Provider *datamodelv1.Provider `protobuf:"bytes,1,opt,name=provider,proto3" json:"provider,omitempty"` - // Workspace for the provider. Empty defaults to "default". - Workspace string `protobuf:"bytes,2,opt,name=workspace,proto3" json:"workspace,omitempty"` +// A single frame on the CLI-to-gateway TCP forward stream. +type TcpForwardFrame struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Payload: + // + // *TcpForwardFrame_Init + // *TcpForwardFrame_Data + Payload isTcpForwardFrame_Payload `protobuf_oneof:"payload"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *CreateProviderRequest) Reset() { - *x = CreateProviderRequest{} - mi := &file_openshell_proto_msgTypes[61] +func (x *TcpForwardFrame) Reset() { + *x = TcpForwardFrame{} + mi := &file_openshell_proto_msgTypes[62] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *CreateProviderRequest) String() string { +func (x *TcpForwardFrame) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CreateProviderRequest) ProtoMessage() {} +func (*TcpForwardFrame) ProtoMessage() {} -func (x *CreateProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[61] +func (x *TcpForwardFrame) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[62] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4724,106 +4559,79 @@ func (x *CreateProviderRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CreateProviderRequest.ProtoReflect.Descriptor instead. -func (*CreateProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{61} +// Deprecated: Use TcpForwardFrame.ProtoReflect.Descriptor instead. +func (*TcpForwardFrame) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{62} } -func (x *CreateProviderRequest) GetProvider() *datamodelv1.Provider { +func (x *TcpForwardFrame) GetPayload() isTcpForwardFrame_Payload { if x != nil { - return x.Provider + return x.Payload } return nil } -func (x *CreateProviderRequest) GetWorkspace() string { +func (x *TcpForwardFrame) GetInit() *TcpForwardInit { if x != nil { - return x.Workspace + if x, ok := x.Payload.(*TcpForwardFrame_Init); ok { + return x.Init + } } - return "" -} - -// Get provider request. -type GetProviderRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - // Workspace scope. Empty defaults to "default". - Workspace string `protobuf:"bytes,2,opt,name=workspace,proto3" json:"workspace,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *GetProviderRequest) Reset() { - *x = GetProviderRequest{} - mi := &file_openshell_proto_msgTypes[62] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *GetProviderRequest) String() string { - return protoimpl.X.MessageStringOf(x) + return nil } -func (*GetProviderRequest) ProtoMessage() {} - -func (x *GetProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[62] +func (x *TcpForwardFrame) GetData() []byte { if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) + if x, ok := x.Payload.(*TcpForwardFrame_Data); ok { + return x.Data } - return ms } - return mi.MessageOf(x) + return nil } -// Deprecated: Use GetProviderRequest.ProtoReflect.Descriptor instead. -func (*GetProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{62} +type isTcpForwardFrame_Payload interface { + isTcpForwardFrame_Payload() } -func (x *GetProviderRequest) GetName() string { - if x != nil { - return x.Name - } - return "" +type TcpForwardFrame_Init struct { + Init *TcpForwardInit `protobuf:"bytes,1,opt,name=init,proto3,oneof"` } -func (x *GetProviderRequest) GetWorkspace() string { - if x != nil { - return x.Workspace - } - return "" +type TcpForwardFrame_Data struct { + Data []byte `protobuf:"bytes,2,opt,name=data,proto3,oneof"` } -// List providers request. -type ListProvidersRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - Limit uint32 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"` - Offset uint32 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"` - // Workspace scope. Empty defaults to "default". - Workspace string `protobuf:"bytes,3,opt,name=workspace,proto3" json:"workspace,omitempty"` - // List across all workspaces. Mutually exclusive with workspace. - AllWorkspaces bool `protobuf:"varint,4,opt,name=all_workspaces,json=allWorkspaces,proto3" json:"all_workspaces,omitempty"` +func (*TcpForwardFrame_Init) isTcpForwardFrame_Payload() {} + +func (*TcpForwardFrame_Data) isTcpForwardFrame_Payload() {} + +// Client-to-server message for interactive exec. +type ExecSandboxInput struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Payload: + // + // *ExecSandboxInput_Start + // *ExecSandboxInput_Stdin + // *ExecSandboxInput_Resize + Payload isExecSandboxInput_Payload `protobuf_oneof:"payload"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListProvidersRequest) Reset() { - *x = ListProvidersRequest{} +func (x *ExecSandboxInput) Reset() { + *x = ExecSandboxInput{} mi := &file_openshell_proto_msgTypes[63] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListProvidersRequest) String() string { +func (x *ExecSandboxInput) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListProvidersRequest) ProtoMessage() {} +func (*ExecSandboxInput) ProtoMessage() {} -func (x *ListProvidersRequest) ProtoReflect() protoreflect.Message { +func (x *ExecSandboxInput) ProtoReflect() protoreflect.Message { mi := &file_openshell_proto_msgTypes[63] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -4835,66 +4643,93 @@ func (x *ListProvidersRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListProvidersRequest.ProtoReflect.Descriptor instead. -func (*ListProvidersRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use ExecSandboxInput.ProtoReflect.Descriptor instead. +func (*ExecSandboxInput) Descriptor() ([]byte, []int) { return file_openshell_proto_rawDescGZIP(), []int{63} } -func (x *ListProvidersRequest) GetLimit() uint32 { +func (x *ExecSandboxInput) GetPayload() isExecSandboxInput_Payload { if x != nil { - return x.Limit + return x.Payload } - return 0 + return nil } -func (x *ListProvidersRequest) GetOffset() uint32 { +func (x *ExecSandboxInput) GetStart() *ExecSandboxRequest { if x != nil { - return x.Offset + if x, ok := x.Payload.(*ExecSandboxInput_Start); ok { + return x.Start + } } - return 0 + return nil } -func (x *ListProvidersRequest) GetWorkspace() string { +func (x *ExecSandboxInput) GetStdin() []byte { if x != nil { - return x.Workspace + if x, ok := x.Payload.(*ExecSandboxInput_Stdin); ok { + return x.Stdin + } } - return "" + return nil } -func (x *ListProvidersRequest) GetAllWorkspaces() bool { +func (x *ExecSandboxInput) GetResize() *ExecSandboxWindowResize { if x != nil { - return x.AllWorkspaces + if x, ok := x.Payload.(*ExecSandboxInput_Resize); ok { + return x.Resize + } } - return false + return nil } -// Update provider request. -type UpdateProviderRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - Provider *datamodelv1.Provider `protobuf:"bytes,1,opt,name=provider,proto3" json:"provider,omitempty"` - // Optional per-credential expiry timestamps to merge into the provider. - // A zero value removes the expiry for that credential. - CredentialExpiresAtMs map[string]int64 `protobuf:"bytes,2,rep,name=credential_expires_at_ms,json=credentialExpiresAtMs,proto3" json:"credential_expires_at_ms,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` - // Workspace scope. Empty defaults to "default". - Workspace string `protobuf:"bytes,3,opt,name=workspace,proto3" json:"workspace,omitempty"` +type isExecSandboxInput_Payload interface { + isExecSandboxInput_Payload() +} + +type ExecSandboxInput_Start struct { + // First message: exec request metadata. + Start *ExecSandboxRequest `protobuf:"bytes,1,opt,name=start,proto3,oneof"` +} + +type ExecSandboxInput_Stdin struct { + // Subsequent messages: raw stdin bytes. + Stdin []byte `protobuf:"bytes,2,opt,name=stdin,proto3,oneof"` +} + +type ExecSandboxInput_Resize struct { + // Terminal window size change. + Resize *ExecSandboxWindowResize `protobuf:"bytes,3,opt,name=resize,proto3,oneof"` +} + +func (*ExecSandboxInput_Start) isExecSandboxInput_Payload() {} + +func (*ExecSandboxInput_Stdin) isExecSandboxInput_Payload() {} + +func (*ExecSandboxInput_Resize) isExecSandboxInput_Payload() {} + +// Terminal window resize event for interactive exec. +type ExecSandboxWindowResize struct { + state protoimpl.MessageState `protogen:"open.v1"` + Cols uint32 `protobuf:"varint,1,opt,name=cols,proto3" json:"cols,omitempty"` + Rows uint32 `protobuf:"varint,2,opt,name=rows,proto3" json:"rows,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *UpdateProviderRequest) Reset() { - *x = UpdateProviderRequest{} +func (x *ExecSandboxWindowResize) Reset() { + *x = ExecSandboxWindowResize{} mi := &file_openshell_proto_msgTypes[64] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *UpdateProviderRequest) String() string { +func (x *ExecSandboxWindowResize) String() string { return protoimpl.X.MessageStringOf(x) } -func (*UpdateProviderRequest) ProtoMessage() {} +func (*ExecSandboxWindowResize) ProtoMessage() {} -func (x *UpdateProviderRequest) ProtoReflect() protoreflect.Message { +func (x *ExecSandboxWindowResize) ProtoReflect() protoreflect.Message { mi := &file_openshell_proto_msgTypes[64] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -4906,56 +4741,57 @@ func (x *UpdateProviderRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use UpdateProviderRequest.ProtoReflect.Descriptor instead. -func (*UpdateProviderRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use ExecSandboxWindowResize.ProtoReflect.Descriptor instead. +func (*ExecSandboxWindowResize) Descriptor() ([]byte, []int) { return file_openshell_proto_rawDescGZIP(), []int{64} } -func (x *UpdateProviderRequest) GetProvider() *datamodelv1.Provider { - if x != nil { - return x.Provider - } - return nil -} - -func (x *UpdateProviderRequest) GetCredentialExpiresAtMs() map[string]int64 { +func (x *ExecSandboxWindowResize) GetCols() uint32 { if x != nil { - return x.CredentialExpiresAtMs + return x.Cols } - return nil + return 0 } -func (x *UpdateProviderRequest) GetWorkspace() string { +func (x *ExecSandboxWindowResize) GetRows() uint32 { if x != nil { - return x.Workspace + return x.Rows } - return "" + return 0 } -// Delete provider request. -type DeleteProviderRequest struct { +// SSH session record stored in persistence. +type SshSession struct { state protoimpl.MessageState `protogen:"open.v1"` - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - // Workspace scope. Empty defaults to "default". - Workspace string `protobuf:"bytes,2,opt,name=workspace,proto3" json:"workspace,omitempty"` + // Kubernetes-style metadata (id, name, labels, timestamps, resource version). + Metadata *datamodelv1.ObjectMeta `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"` + // Sandbox id. + SandboxId string `protobuf:"bytes,2,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` + // Session token. + Token string `protobuf:"bytes,3,opt,name=token,proto3" json:"token,omitempty"` + // Expiry timestamp in milliseconds since epoch. 0 means no expiry + // (backward-compatible default for sessions created before this field existed). + ExpiresAtMs int64 `protobuf:"varint,4,opt,name=expires_at_ms,json=expiresAtMs,proto3" json:"expires_at_ms,omitempty"` + // Revoked flag. + Revoked bool `protobuf:"varint,5,opt,name=revoked,proto3" json:"revoked,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *DeleteProviderRequest) Reset() { - *x = DeleteProviderRequest{} +func (x *SshSession) Reset() { + *x = SshSession{} mi := &file_openshell_proto_msgTypes[65] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *DeleteProviderRequest) String() string { +func (x *SshSession) String() string { return protoimpl.X.MessageStringOf(x) } -func (*DeleteProviderRequest) ProtoMessage() {} +func (*SshSession) ProtoMessage() {} -func (x *DeleteProviderRequest) ProtoReflect() protoreflect.Message { +func (x *SshSession) ProtoReflect() protoreflect.Message { mi := &file_openshell_proto_msgTypes[65] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -4967,47 +4803,89 @@ func (x *DeleteProviderRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use DeleteProviderRequest.ProtoReflect.Descriptor instead. -func (*DeleteProviderRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use SshSession.ProtoReflect.Descriptor instead. +func (*SshSession) Descriptor() ([]byte, []int) { return file_openshell_proto_rawDescGZIP(), []int{65} } -func (x *DeleteProviderRequest) GetName() string { +func (x *SshSession) GetMetadata() *datamodelv1.ObjectMeta { if x != nil { - return x.Name + return x.Metadata + } + return nil +} + +func (x *SshSession) GetSandboxId() string { + if x != nil { + return x.SandboxId } return "" } -func (x *DeleteProviderRequest) GetWorkspace() string { +func (x *SshSession) GetToken() string { if x != nil { - return x.Workspace + return x.Token } return "" } -// Provider response. -type ProviderResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Provider *datamodelv1.Provider `protobuf:"bytes,1,opt,name=provider,proto3" json:"provider,omitempty"` +func (x *SshSession) GetExpiresAtMs() int64 { + if x != nil { + return x.ExpiresAtMs + } + return 0 +} + +func (x *SshSession) GetRevoked() bool { + if x != nil { + return x.Revoked + } + return false +} + +// Watch sandbox request. +type WatchSandboxRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Sandbox id. + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // Stream sandbox status snapshots. + FollowStatus bool `protobuf:"varint,2,opt,name=follow_status,json=followStatus,proto3" json:"follow_status,omitempty"` + // Stream openshell-server process logs correlated to this sandbox. + FollowLogs bool `protobuf:"varint,3,opt,name=follow_logs,json=followLogs,proto3" json:"follow_logs,omitempty"` + // Stream platform events correlated to this sandbox. + FollowEvents bool `protobuf:"varint,4,opt,name=follow_events,json=followEvents,proto3" json:"follow_events,omitempty"` + // Replay the last N log lines (best-effort) before following. + LogTailLines uint32 `protobuf:"varint,5,opt,name=log_tail_lines,json=logTailLines,proto3" json:"log_tail_lines,omitempty"` + // Replay the last N platform events (best-effort) before following. + EventTail uint32 `protobuf:"varint,6,opt,name=event_tail,json=eventTail,proto3" json:"event_tail,omitempty"` + // Stop streaming once the sandbox reaches READY or a terminal result phase + // (COMPLETED, STOPPED, or ERROR). + StopOnTerminal bool `protobuf:"varint,7,opt,name=stop_on_terminal,json=stopOnTerminal,proto3" json:"stop_on_terminal,omitempty"` + // Only include log lines with timestamp >= this value (milliseconds since epoch). + // 0 means no time filter. Applies to both tail replay and live streaming. + LogSinceMs int64 `protobuf:"varint,8,opt,name=log_since_ms,json=logSinceMs,proto3" json:"log_since_ms,omitempty"` + // Filter by log source (e.g. "gateway", "sandbox"). Empty means all sources. + LogSources []string `protobuf:"bytes,9,rep,name=log_sources,json=logSources,proto3" json:"log_sources,omitempty"` + // Minimum log level to include (e.g. "INFO", "WARN", "ERROR"). Empty means all levels. + LogMinLevel string `protobuf:"bytes,10,opt,name=log_min_level,json=logMinLevel,proto3" json:"log_min_level,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ProviderResponse) Reset() { - *x = ProviderResponse{} +func (x *WatchSandboxRequest) Reset() { + *x = WatchSandboxRequest{} mi := &file_openshell_proto_msgTypes[66] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ProviderResponse) String() string { +func (x *WatchSandboxRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ProviderResponse) ProtoMessage() {} +func (*WatchSandboxRequest) ProtoMessage() {} -func (x *ProviderResponse) ProtoReflect() protoreflect.Message { +func (x *WatchSandboxRequest) ProtoReflect() protoreflect.Message { mi := &file_openshell_proto_msgTypes[66] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -5019,90 +4897,111 @@ func (x *ProviderResponse) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ProviderResponse.ProtoReflect.Descriptor instead. -func (*ProviderResponse) Descriptor() ([]byte, []int) { +// Deprecated: Use WatchSandboxRequest.ProtoReflect.Descriptor instead. +func (*WatchSandboxRequest) Descriptor() ([]byte, []int) { return file_openshell_proto_rawDescGZIP(), []int{66} } -func (x *ProviderResponse) GetProvider() *datamodelv1.Provider { +func (x *WatchSandboxRequest) GetId() string { if x != nil { - return x.Provider + return x.Id } - return nil + return "" } -// List providers response. -type ListProvidersResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Providers []*datamodelv1.Provider `protobuf:"bytes,1,rep,name=providers,proto3" json:"providers,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +func (x *WatchSandboxRequest) GetFollowStatus() bool { + if x != nil { + return x.FollowStatus + } + return false } -func (x *ListProvidersResponse) Reset() { - *x = ListProvidersResponse{} - mi := &file_openshell_proto_msgTypes[67] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) +func (x *WatchSandboxRequest) GetFollowLogs() bool { + if x != nil { + return x.FollowLogs + } + return false } -func (x *ListProvidersResponse) String() string { - return protoimpl.X.MessageStringOf(x) +func (x *WatchSandboxRequest) GetFollowEvents() bool { + if x != nil { + return x.FollowEvents + } + return false } -func (*ListProvidersResponse) ProtoMessage() {} +func (x *WatchSandboxRequest) GetLogTailLines() uint32 { + if x != nil { + return x.LogTailLines + } + return 0 +} -func (x *ListProvidersResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[67] +func (x *WatchSandboxRequest) GetEventTail() uint32 { if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms + return x.EventTail } - return mi.MessageOf(x) + return 0 } -// Deprecated: Use ListProvidersResponse.ProtoReflect.Descriptor instead. -func (*ListProvidersResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{67} +func (x *WatchSandboxRequest) GetStopOnTerminal() bool { + if x != nil { + return x.StopOnTerminal + } + return false } -func (x *ListProvidersResponse) GetProviders() []*datamodelv1.Provider { +func (x *WatchSandboxRequest) GetLogSinceMs() int64 { if x != nil { - return x.Providers + return x.LogSinceMs + } + return 0 +} + +func (x *WatchSandboxRequest) GetLogSources() []string { + if x != nil { + return x.LogSources } return nil } -// List provider type profiles request. -type ListProviderProfilesRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - Limit uint32 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"` - Offset uint32 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"` - // Workspace scope. When set, returns workspace-scoped + built-in profiles. - // When empty, returns platform-scoped + built-in only. - Workspace string `protobuf:"bytes,3,opt,name=workspace,proto3" json:"workspace,omitempty"` +func (x *WatchSandboxRequest) GetLogMinLevel() string { + if x != nil { + return x.LogMinLevel + } + return "" +} + +// One event in a sandbox watch stream. +type SandboxStreamEvent struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Payload: + // + // *SandboxStreamEvent_Sandbox + // *SandboxStreamEvent_Log + // *SandboxStreamEvent_Event + // *SandboxStreamEvent_Warning + // *SandboxStreamEvent_DraftPolicyUpdate + Payload isSandboxStreamEvent_Payload `protobuf_oneof:"payload"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListProviderProfilesRequest) Reset() { - *x = ListProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[68] +func (x *SandboxStreamEvent) Reset() { + *x = SandboxStreamEvent{} + mi := &file_openshell_proto_msgTypes[67] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListProviderProfilesRequest) String() string { +func (x *SandboxStreamEvent) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListProviderProfilesRequest) ProtoMessage() {} +func (*SandboxStreamEvent) ProtoMessage() {} -func (x *ListProviderProfilesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[68] +func (x *SandboxStreamEvent) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[67] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5113,168 +5012,134 @@ func (x *ListProviderProfilesRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListProviderProfilesRequest.ProtoReflect.Descriptor instead. -func (*ListProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{68} +// Deprecated: Use SandboxStreamEvent.ProtoReflect.Descriptor instead. +func (*SandboxStreamEvent) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{67} } -func (x *ListProviderProfilesRequest) GetLimit() uint32 { +func (x *SandboxStreamEvent) GetPayload() isSandboxStreamEvent_Payload { if x != nil { - return x.Limit + return x.Payload } - return 0 + return nil } -func (x *ListProviderProfilesRequest) GetOffset() uint32 { +func (x *SandboxStreamEvent) GetSandbox() *Sandbox { if x != nil { - return x.Offset + if x, ok := x.Payload.(*SandboxStreamEvent_Sandbox); ok { + return x.Sandbox + } } - return 0 + return nil } -func (x *ListProviderProfilesRequest) GetWorkspace() string { +func (x *SandboxStreamEvent) GetLog() *SandboxLogLine { if x != nil { - return x.Workspace + if x, ok := x.Payload.(*SandboxStreamEvent_Log); ok { + return x.Log + } } - return "" -} - -// Fetch provider type profile request. -type GetProviderProfileRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - // Workspace scope for two-tier profile resolution. When set, checks - // workspace-scoped profiles first, then platform-scoped, then built-in. - // When empty, checks platform-scoped then built-in only. - Workspace string `protobuf:"bytes,2,opt,name=workspace,proto3" json:"workspace,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *GetProviderProfileRequest) Reset() { - *x = GetProviderProfileRequest{} - mi := &file_openshell_proto_msgTypes[69] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *GetProviderProfileRequest) String() string { - return protoimpl.X.MessageStringOf(x) + return nil } -func (*GetProviderProfileRequest) ProtoMessage() {} - -func (x *GetProviderProfileRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[69] +func (x *SandboxStreamEvent) GetEvent() *PlatformEvent { if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) + if x, ok := x.Payload.(*SandboxStreamEvent_Event); ok { + return x.Event } - return ms } - return mi.MessageOf(x) -} - -// Deprecated: Use GetProviderProfileRequest.ProtoReflect.Descriptor instead. -func (*GetProviderProfileRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{69} + return nil } -func (x *GetProviderProfileRequest) GetId() string { +func (x *SandboxStreamEvent) GetWarning() *SandboxStreamWarning { if x != nil { - return x.Id + if x, ok := x.Payload.(*SandboxStreamEvent_Warning); ok { + return x.Warning + } } - return "" + return nil } -func (x *GetProviderProfileRequest) GetWorkspace() string { +func (x *SandboxStreamEvent) GetDraftPolicyUpdate() *DraftPolicyUpdate { if x != nil { - return x.Workspace + if x, ok := x.Payload.(*SandboxStreamEvent_DraftPolicyUpdate); ok { + return x.DraftPolicyUpdate + } } - return "" + return nil } -// Provider profile payload with optional source metadata for diagnostics. -type ProviderProfileImportItem struct { - state protoimpl.MessageState `protogen:"open.v1"` - Profile *ProviderProfile `protobuf:"bytes,1,opt,name=profile,proto3" json:"profile,omitempty"` - Source string `protobuf:"bytes,2,opt,name=source,proto3" json:"source,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type isSandboxStreamEvent_Payload interface { + isSandboxStreamEvent_Payload() } -func (x *ProviderProfileImportItem) Reset() { - *x = ProviderProfileImportItem{} - mi := &file_openshell_proto_msgTypes[70] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) +type SandboxStreamEvent_Sandbox struct { + // Latest sandbox snapshot. + Sandbox *Sandbox `protobuf:"bytes,1,opt,name=sandbox,proto3,oneof"` } -func (x *ProviderProfileImportItem) String() string { - return protoimpl.X.MessageStringOf(x) +type SandboxStreamEvent_Log struct { + // One server log line/event. + Log *SandboxLogLine `protobuf:"bytes,2,opt,name=log,proto3,oneof"` } -func (*ProviderProfileImportItem) ProtoMessage() {} - -func (x *ProviderProfileImportItem) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[70] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) +type SandboxStreamEvent_Event struct { + // One platform event. + Event *PlatformEvent `protobuf:"bytes,3,opt,name=event,proto3,oneof"` } -// Deprecated: Use ProviderProfileImportItem.ProtoReflect.Descriptor instead. -func (*ProviderProfileImportItem) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{70} +type SandboxStreamEvent_Warning struct { + // Warning from the server (e.g. missed messages due to lag). + Warning *SandboxStreamWarning `protobuf:"bytes,4,opt,name=warning,proto3,oneof"` } -func (x *ProviderProfileImportItem) GetProfile() *ProviderProfile { - if x != nil { - return x.Profile - } - return nil +type SandboxStreamEvent_DraftPolicyUpdate struct { + // Draft policy update notification. + DraftPolicyUpdate *DraftPolicyUpdate `protobuf:"bytes,5,opt,name=draft_policy_update,json=draftPolicyUpdate,proto3,oneof"` } -func (x *ProviderProfileImportItem) GetSource() string { - if x != nil { - return x.Source - } - return "" -} +func (*SandboxStreamEvent_Sandbox) isSandboxStreamEvent_Payload() {} -// Provider profile validation diagnostic. -type ProviderProfileDiagnostic struct { - state protoimpl.MessageState `protogen:"open.v1"` - Source string `protobuf:"bytes,1,opt,name=source,proto3" json:"source,omitempty"` - ProfileId string `protobuf:"bytes,2,opt,name=profile_id,json=profileId,proto3" json:"profile_id,omitempty"` - Field string `protobuf:"bytes,3,opt,name=field,proto3" json:"field,omitempty"` - Message string `protobuf:"bytes,4,opt,name=message,proto3" json:"message,omitempty"` - Severity string `protobuf:"bytes,5,opt,name=severity,proto3" json:"severity,omitempty"` +func (*SandboxStreamEvent_Log) isSandboxStreamEvent_Payload() {} + +func (*SandboxStreamEvent_Event) isSandboxStreamEvent_Payload() {} + +func (*SandboxStreamEvent_Warning) isSandboxStreamEvent_Payload() {} + +func (*SandboxStreamEvent_DraftPolicyUpdate) isSandboxStreamEvent_Payload() {} + +// Log line correlated to a sandbox. +type SandboxLogLine struct { + state protoimpl.MessageState `protogen:"open.v1"` + SandboxId string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` + TimestampMs int64 `protobuf:"varint,2,opt,name=timestamp_ms,json=timestampMs,proto3" json:"timestamp_ms,omitempty"` + Level string `protobuf:"bytes,3,opt,name=level,proto3" json:"level,omitempty"` + Target string `protobuf:"bytes,4,opt,name=target,proto3" json:"target,omitempty"` + Message string `protobuf:"bytes,5,opt,name=message,proto3" json:"message,omitempty"` + // Log source: "gateway" (server-side) or "sandbox" (supervisor). + // Empty is treated as "gateway" for backward compatibility. + Source string `protobuf:"bytes,6,opt,name=source,proto3" json:"source,omitempty"` + // Structured key-value fields from the tracing event (e.g. dst_host, action). + Fields map[string]string `protobuf:"bytes,7,rep,name=fields,proto3" json:"fields,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ProviderProfileDiagnostic) Reset() { - *x = ProviderProfileDiagnostic{} - mi := &file_openshell_proto_msgTypes[71] +func (x *SandboxLogLine) Reset() { + *x = SandboxLogLine{} + mi := &file_openshell_proto_msgTypes[68] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ProviderProfileDiagnostic) String() string { +func (x *SandboxLogLine) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ProviderProfileDiagnostic) ProtoMessage() {} +func (*SandboxLogLine) ProtoMessage() {} -func (x *ProviderProfileDiagnostic) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[71] +func (x *SandboxLogLine) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[68] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5285,78 +5150,82 @@ func (x *ProviderProfileDiagnostic) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ProviderProfileDiagnostic.ProtoReflect.Descriptor instead. -func (*ProviderProfileDiagnostic) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{71} +// Deprecated: Use SandboxLogLine.ProtoReflect.Descriptor instead. +func (*SandboxLogLine) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{68} } -func (x *ProviderProfileDiagnostic) GetSource() string { +func (x *SandboxLogLine) GetSandboxId() string { if x != nil { - return x.Source + return x.SandboxId } return "" } -func (x *ProviderProfileDiagnostic) GetProfileId() string { +func (x *SandboxLogLine) GetTimestampMs() int64 { if x != nil { - return x.ProfileId + return x.TimestampMs + } + return 0 +} + +func (x *SandboxLogLine) GetLevel() string { + if x != nil { + return x.Level } return "" } -func (x *ProviderProfileDiagnostic) GetField() string { +func (x *SandboxLogLine) GetTarget() string { if x != nil { - return x.Field + return x.Target } return "" } -func (x *ProviderProfileDiagnostic) GetMessage() string { +func (x *SandboxLogLine) GetMessage() string { if x != nil { return x.Message } return "" } -func (x *ProviderProfileDiagnostic) GetSeverity() string { +func (x *SandboxLogLine) GetSource() string { if x != nil { - return x.Severity + return x.Source } return "" } -// Endpoint selector for token grant audience overrides. -type ProviderCredentialTokenGrantAudienceOverride struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Optional: endpoint host selector. If omitted, inherits the profile endpoint host. - Host string `protobuf:"bytes,1,opt,name=host,proto3" json:"host,omitempty"` - // Optional: endpoint port selector. If omitted, matches the expanded profile endpoint port. - Port uint32 `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"` - // Optional: endpoint path selector. If omitted, inherits the profile endpoint path. - Path string `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"` - // Resource audience to request for matching endpoints. - Audience string `protobuf:"bytes,4,opt,name=audience,proto3" json:"audience,omitempty"` - // Optional: OAuth2 scopes to request. If omitted, inherits the token grant scopes. - Scopes []string `protobuf:"bytes,5,rep,name=scopes,proto3" json:"scopes,omitempty"` +func (x *SandboxLogLine) GetFields() map[string]string { + if x != nil { + return x.Fields + } + return nil +} + +type SandboxStreamWarning struct { + state protoimpl.MessageState `protogen:"open.v1"` + Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ProviderCredentialTokenGrantAudienceOverride) Reset() { - *x = ProviderCredentialTokenGrantAudienceOverride{} - mi := &file_openshell_proto_msgTypes[72] +func (x *SandboxStreamWarning) Reset() { + *x = SandboxStreamWarning{} + mi := &file_openshell_proto_msgTypes[69] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ProviderCredentialTokenGrantAudienceOverride) String() string { +func (x *SandboxStreamWarning) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ProviderCredentialTokenGrantAudienceOverride) ProtoMessage() {} +func (*SandboxStreamWarning) ProtoMessage() {} -func (x *ProviderCredentialTokenGrantAudienceOverride) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[72] +func (x *SandboxStreamWarning) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[69] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5367,75 +5236,43 @@ func (x *ProviderCredentialTokenGrantAudienceOverride) ProtoReflect() protorefle return mi.MessageOf(x) } -// Deprecated: Use ProviderCredentialTokenGrantAudienceOverride.ProtoReflect.Descriptor instead. -func (*ProviderCredentialTokenGrantAudienceOverride) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{72} +// Deprecated: Use SandboxStreamWarning.ProtoReflect.Descriptor instead. +func (*SandboxStreamWarning) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{69} } -func (x *ProviderCredentialTokenGrantAudienceOverride) GetHost() string { +func (x *SandboxStreamWarning) GetMessage() string { if x != nil { - return x.Host + return x.Message } return "" } -func (x *ProviderCredentialTokenGrantAudienceOverride) GetPort() uint32 { - if x != nil { - return x.Port - } - return 0 -} - -func (x *ProviderCredentialTokenGrantAudienceOverride) GetPath() string { - if x != nil { - return x.Path - } - return "" -} - -func (x *ProviderCredentialTokenGrantAudienceOverride) GetAudience() string { - if x != nil { - return x.Audience - } - return "" -} - -func (x *ProviderCredentialTokenGrantAudienceOverride) GetScopes() []string { - if x != nil { - return x.Scopes - } - return nil -} - -type ProviderCredentialTokenGrantSubjectToken struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Source for the token exchange subject token. Phase one supports - // "provider_credential". - Source string `protobuf:"bytes,1,opt,name=source,proto3" json:"source,omitempty"` - // Provider credential key that stores the subject token. - Credential string `protobuf:"bytes,2,opt,name=credential,proto3" json:"credential,omitempty"` - // OAuth2 subject_token_type. If omitted, OpenShell uses - // urn:ietf:params:oauth:token-type:access_token. - SubjectTokenType string `protobuf:"bytes,3,opt,name=subject_token_type,json=subjectTokenType,proto3" json:"subject_token_type,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +// Create provider request. +type CreateProviderRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Provider *datamodelv1.Provider `protobuf:"bytes,1,opt,name=provider,proto3" json:"provider,omitempty"` + // Workspace for the provider. Empty defaults to "default". + Workspace string `protobuf:"bytes,2,opt,name=workspace,proto3" json:"workspace,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *ProviderCredentialTokenGrantSubjectToken) Reset() { - *x = ProviderCredentialTokenGrantSubjectToken{} - mi := &file_openshell_proto_msgTypes[73] +func (x *CreateProviderRequest) Reset() { + *x = CreateProviderRequest{} + mi := &file_openshell_proto_msgTypes[70] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ProviderCredentialTokenGrantSubjectToken) String() string { +func (x *CreateProviderRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ProviderCredentialTokenGrantSubjectToken) ProtoMessage() {} +func (*CreateProviderRequest) ProtoMessage() {} -func (x *ProviderCredentialTokenGrantSubjectToken) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[73] +func (x *CreateProviderRequest) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[70] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5446,78 +5283,50 @@ func (x *ProviderCredentialTokenGrantSubjectToken) ProtoReflect() protoreflect.M return mi.MessageOf(x) } -// Deprecated: Use ProviderCredentialTokenGrantSubjectToken.ProtoReflect.Descriptor instead. -func (*ProviderCredentialTokenGrantSubjectToken) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{73} -} - -func (x *ProviderCredentialTokenGrantSubjectToken) GetSource() string { - if x != nil { - return x.Source - } - return "" +// Deprecated: Use CreateProviderRequest.ProtoReflect.Descriptor instead. +func (*CreateProviderRequest) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{70} } -func (x *ProviderCredentialTokenGrantSubjectToken) GetCredential() string { +func (x *CreateProviderRequest) GetProvider() *datamodelv1.Provider { if x != nil { - return x.Credential + return x.Provider } - return "" + return nil } -func (x *ProviderCredentialTokenGrantSubjectToken) GetSubjectTokenType() string { +func (x *CreateProviderRequest) GetWorkspace() string { if x != nil { - return x.SubjectTokenType + return x.Workspace } return "" } -type ProviderCredentialTokenGrant struct { +// Get provider request. +type GetProviderRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // OAuth2 token endpoint URL (e.g., https://keycloak.example.com/realms/my-realm/protocol/openid-connect/token) - TokenEndpoint string `protobuf:"bytes,1,opt,name=token_endpoint,json=tokenEndpoint,proto3" json:"token_endpoint,omitempty"` - // Optional: default resource audience to request from the token service - Audience string `protobuf:"bytes,2,opt,name=audience,proto3" json:"audience,omitempty"` - // Optional: audience to request when fetching the JWT-SVID from SPIRE. - // If omitted, the sandbox derives this from token_endpoint. - JwtSvidAudience string `protobuf:"bytes,6,opt,name=jwt_svid_audience,json=jwtSvidAudience,proto3" json:"jwt_svid_audience,omitempty"` - // Optional: OAuth2 scopes to request - Scopes []string `protobuf:"bytes,3,rep,name=scopes,proto3" json:"scopes,omitempty"` - // Optional: override token cache TTL (seconds) - // If 0 or omitted, use expires_in from token response - CacheTtlSeconds int64 `protobuf:"varint,4,opt,name=cache_ttl_seconds,json=cacheTtlSeconds,proto3" json:"cache_ttl_seconds,omitempty"` - // Optional: endpoint-specific resource audience overrides. - AudienceOverrides []*ProviderCredentialTokenGrantAudienceOverride `protobuf:"bytes,5,rep,name=audience_overrides,json=audienceOverrides,proto3" json:"audience_overrides,omitempty"` - // Optional: OAuth2 client_assertion_type value. If omitted, OpenShell uses - // urn:ietf:params:oauth:client-assertion-type:jwt-bearer. - ClientAssertionType string `protobuf:"bytes,7,opt,name=client_assertion_type,json=clientAssertionType,proto3" json:"client_assertion_type,omitempty"` - // Grant type. If omitted/unspecified, OpenShell treats this as client_credentials - // for backwards compatibility. - GrantType ProviderCredentialTokenGrantType `protobuf:"varint,8,opt,name=grant_type,json=grantType,proto3,enum=openshell.v1.ProviderCredentialTokenGrantType" json:"grant_type,omitempty"` - // Subject token metadata for token_exchange grants. - SubjectToken *ProviderCredentialTokenGrantSubjectToken `protobuf:"bytes,9,opt,name=subject_token,json=subjectToken,proto3" json:"subject_token,omitempty"` - // OAuth2 requested_token_type. If omitted for token_exchange, OpenShell uses - // urn:ietf:params:oauth:token-type:access_token. - RequestedTokenType string `protobuf:"bytes,10,opt,name=requested_token_type,json=requestedTokenType,proto3" json:"requested_token_type,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // Workspace scope. Empty defaults to "default". + Workspace string `protobuf:"bytes,2,opt,name=workspace,proto3" json:"workspace,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *ProviderCredentialTokenGrant) Reset() { - *x = ProviderCredentialTokenGrant{} - mi := &file_openshell_proto_msgTypes[74] +func (x *GetProviderRequest) Reset() { + *x = GetProviderRequest{} + mi := &file_openshell_proto_msgTypes[71] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ProviderCredentialTokenGrant) String() string { +func (x *GetProviderRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ProviderCredentialTokenGrant) ProtoMessage() {} +func (*GetProviderRequest) ProtoMessage() {} -func (x *ProviderCredentialTokenGrant) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[74] +func (x *GetProviderRequest) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[71] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5528,113 +5337,124 @@ func (x *ProviderCredentialTokenGrant) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ProviderCredentialTokenGrant.ProtoReflect.Descriptor instead. -func (*ProviderCredentialTokenGrant) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{74} +// Deprecated: Use GetProviderRequest.ProtoReflect.Descriptor instead. +func (*GetProviderRequest) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{71} } -func (x *ProviderCredentialTokenGrant) GetTokenEndpoint() string { +func (x *GetProviderRequest) GetName() string { if x != nil { - return x.TokenEndpoint + return x.Name } return "" } -func (x *ProviderCredentialTokenGrant) GetAudience() string { +func (x *GetProviderRequest) GetWorkspace() string { if x != nil { - return x.Audience + return x.Workspace } return "" } -func (x *ProviderCredentialTokenGrant) GetJwtSvidAudience() string { - if x != nil { - return x.JwtSvidAudience - } - return "" +// List providers request. +type ListProvidersRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Limit uint32 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"` + Offset uint32 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"` + // Workspace scope. Empty defaults to "default". + Workspace string `protobuf:"bytes,3,opt,name=workspace,proto3" json:"workspace,omitempty"` + // List across all workspaces. Mutually exclusive with workspace. + AllWorkspaces bool `protobuf:"varint,4,opt,name=all_workspaces,json=allWorkspaces,proto3" json:"all_workspaces,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *ProviderCredentialTokenGrant) GetScopes() []string { - if x != nil { - return x.Scopes - } - return nil +func (x *ListProvidersRequest) Reset() { + *x = ListProvidersRequest{} + mi := &file_openshell_proto_msgTypes[72] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } -func (x *ProviderCredentialTokenGrant) GetCacheTtlSeconds() int64 { - if x != nil { - return x.CacheTtlSeconds - } - return 0 +func (x *ListProvidersRequest) String() string { + return protoimpl.X.MessageStringOf(x) } -func (x *ProviderCredentialTokenGrant) GetAudienceOverrides() []*ProviderCredentialTokenGrantAudienceOverride { +func (*ListProvidersRequest) ProtoMessage() {} + +func (x *ListProvidersRequest) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[72] if x != nil { - return x.AudienceOverrides + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return nil + return mi.MessageOf(x) } -func (x *ProviderCredentialTokenGrant) GetClientAssertionType() string { +// Deprecated: Use ListProvidersRequest.ProtoReflect.Descriptor instead. +func (*ListProvidersRequest) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{72} +} + +func (x *ListProvidersRequest) GetLimit() uint32 { if x != nil { - return x.ClientAssertionType + return x.Limit } - return "" + return 0 } -func (x *ProviderCredentialTokenGrant) GetGrantType() ProviderCredentialTokenGrantType { +func (x *ListProvidersRequest) GetOffset() uint32 { if x != nil { - return x.GrantType + return x.Offset } - return ProviderCredentialTokenGrantType_PROVIDER_CREDENTIAL_TOKEN_GRANT_TYPE_UNSPECIFIED + return 0 } -func (x *ProviderCredentialTokenGrant) GetSubjectToken() *ProviderCredentialTokenGrantSubjectToken { +func (x *ListProvidersRequest) GetWorkspace() string { if x != nil { - return x.SubjectToken + return x.Workspace } - return nil + return "" } -func (x *ProviderCredentialTokenGrant) GetRequestedTokenType() string { +func (x *ListProvidersRequest) GetAllWorkspaces() bool { if x != nil { - return x.RequestedTokenType + return x.AllWorkspaces } - return "" + return false } -// Provider credential declaration. -type ProviderProfileCredential struct { - state protoimpl.MessageState `protogen:"open.v1"` - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` - EnvVars []string `protobuf:"bytes,3,rep,name=env_vars,json=envVars,proto3" json:"env_vars,omitempty"` - Required bool `protobuf:"varint,4,opt,name=required,proto3" json:"required,omitempty"` - AuthStyle string `protobuf:"bytes,5,opt,name=auth_style,json=authStyle,proto3" json:"auth_style,omitempty"` - HeaderName string `protobuf:"bytes,6,opt,name=header_name,json=headerName,proto3" json:"header_name,omitempty"` - QueryParam string `protobuf:"bytes,7,opt,name=query_param,json=queryParam,proto3" json:"query_param,omitempty"` - Refresh *ProviderCredentialRefresh `protobuf:"bytes,8,opt,name=refresh,proto3" json:"refresh,omitempty"` - PathTemplate string `protobuf:"bytes,9,opt,name=path_template,json=pathTemplate,proto3" json:"path_template,omitempty"` - TokenGrant *ProviderCredentialTokenGrant `protobuf:"bytes,10,opt,name=token_grant,json=tokenGrant,proto3" json:"token_grant,omitempty"` +// Update provider request. +type UpdateProviderRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Provider *datamodelv1.Provider `protobuf:"bytes,1,opt,name=provider,proto3" json:"provider,omitempty"` + // Optional per-credential expiry timestamps to merge into the provider. + // A zero value removes the expiry for that credential. + CredentialExpiresAtMs map[string]int64 `protobuf:"bytes,2,rep,name=credential_expires_at_ms,json=credentialExpiresAtMs,proto3" json:"credential_expires_at_ms,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + // Workspace scope. Empty defaults to "default". + Workspace string `protobuf:"bytes,3,opt,name=workspace,proto3" json:"workspace,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ProviderProfileCredential) Reset() { - *x = ProviderProfileCredential{} - mi := &file_openshell_proto_msgTypes[75] +func (x *UpdateProviderRequest) Reset() { + *x = UpdateProviderRequest{} + mi := &file_openshell_proto_msgTypes[73] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ProviderProfileCredential) String() string { +func (x *UpdateProviderRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ProviderProfileCredential) ProtoMessage() {} +func (*UpdateProviderRequest) ProtoMessage() {} -func (x *ProviderProfileCredential) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[75] +func (x *UpdateProviderRequest) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[73] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5645,176 +5465,1507 @@ func (x *ProviderProfileCredential) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ProviderProfileCredential.ProtoReflect.Descriptor instead. -func (*ProviderProfileCredential) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{75} +// Deprecated: Use UpdateProviderRequest.ProtoReflect.Descriptor instead. +func (*UpdateProviderRequest) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{73} } -func (x *ProviderProfileCredential) GetName() string { +func (x *UpdateProviderRequest) GetProvider() *datamodelv1.Provider { + if x != nil { + return x.Provider + } + return nil +} + +func (x *UpdateProviderRequest) GetCredentialExpiresAtMs() map[string]int64 { + if x != nil { + return x.CredentialExpiresAtMs + } + return nil +} + +func (x *UpdateProviderRequest) GetWorkspace() string { + if x != nil { + return x.Workspace + } + return "" +} + +// Delete provider request. +type DeleteProviderRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // Workspace scope. Empty defaults to "default". + Workspace string `protobuf:"bytes,2,opt,name=workspace,proto3" json:"workspace,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DeleteProviderRequest) Reset() { + *x = DeleteProviderRequest{} + mi := &file_openshell_proto_msgTypes[74] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DeleteProviderRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteProviderRequest) ProtoMessage() {} + +func (x *DeleteProviderRequest) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[74] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteProviderRequest.ProtoReflect.Descriptor instead. +func (*DeleteProviderRequest) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{74} +} + +func (x *DeleteProviderRequest) GetName() string { if x != nil { return x.Name } - return "" + return "" +} + +func (x *DeleteProviderRequest) GetWorkspace() string { + if x != nil { + return x.Workspace + } + return "" +} + +// Provider response. +type ProviderResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Provider *datamodelv1.Provider `protobuf:"bytes,1,opt,name=provider,proto3" json:"provider,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ProviderResponse) Reset() { + *x = ProviderResponse{} + mi := &file_openshell_proto_msgTypes[75] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ProviderResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProviderResponse) ProtoMessage() {} + +func (x *ProviderResponse) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[75] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProviderResponse.ProtoReflect.Descriptor instead. +func (*ProviderResponse) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{75} +} + +func (x *ProviderResponse) GetProvider() *datamodelv1.Provider { + if x != nil { + return x.Provider + } + return nil +} + +// List providers response. +type ListProvidersResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Providers []*datamodelv1.Provider `protobuf:"bytes,1,rep,name=providers,proto3" json:"providers,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListProvidersResponse) Reset() { + *x = ListProvidersResponse{} + mi := &file_openshell_proto_msgTypes[76] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListProvidersResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListProvidersResponse) ProtoMessage() {} + +func (x *ListProvidersResponse) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[76] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListProvidersResponse.ProtoReflect.Descriptor instead. +func (*ListProvidersResponse) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{76} +} + +func (x *ListProvidersResponse) GetProviders() []*datamodelv1.Provider { + if x != nil { + return x.Providers + } + return nil +} + +// List provider type profiles request. +type ListProviderProfilesRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Limit uint32 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"` + Offset uint32 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"` + // Workspace scope. When set, returns workspace-scoped + built-in profiles. + // When empty, returns platform-scoped + built-in only. + Workspace string `protobuf:"bytes,3,opt,name=workspace,proto3" json:"workspace,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListProviderProfilesRequest) Reset() { + *x = ListProviderProfilesRequest{} + mi := &file_openshell_proto_msgTypes[77] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListProviderProfilesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListProviderProfilesRequest) ProtoMessage() {} + +func (x *ListProviderProfilesRequest) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[77] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListProviderProfilesRequest.ProtoReflect.Descriptor instead. +func (*ListProviderProfilesRequest) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{77} +} + +func (x *ListProviderProfilesRequest) GetLimit() uint32 { + if x != nil { + return x.Limit + } + return 0 +} + +func (x *ListProviderProfilesRequest) GetOffset() uint32 { + if x != nil { + return x.Offset + } + return 0 +} + +func (x *ListProviderProfilesRequest) GetWorkspace() string { + if x != nil { + return x.Workspace + } + return "" +} + +// Fetch provider type profile request. +type GetProviderProfileRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // Workspace scope for two-tier profile resolution. When set, checks + // workspace-scoped profiles first, then platform-scoped, then built-in. + // When empty, checks platform-scoped then built-in only. + Workspace string `protobuf:"bytes,2,opt,name=workspace,proto3" json:"workspace,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetProviderProfileRequest) Reset() { + *x = GetProviderProfileRequest{} + mi := &file_openshell_proto_msgTypes[78] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetProviderProfileRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetProviderProfileRequest) ProtoMessage() {} + +func (x *GetProviderProfileRequest) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[78] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetProviderProfileRequest.ProtoReflect.Descriptor instead. +func (*GetProviderProfileRequest) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{78} +} + +func (x *GetProviderProfileRequest) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *GetProviderProfileRequest) GetWorkspace() string { + if x != nil { + return x.Workspace + } + return "" +} + +// Provider profile payload with optional source metadata for diagnostics. +type ProviderProfileImportItem struct { + state protoimpl.MessageState `protogen:"open.v1"` + Profile *ProviderProfile `protobuf:"bytes,1,opt,name=profile,proto3" json:"profile,omitempty"` + Source string `protobuf:"bytes,2,opt,name=source,proto3" json:"source,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ProviderProfileImportItem) Reset() { + *x = ProviderProfileImportItem{} + mi := &file_openshell_proto_msgTypes[79] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ProviderProfileImportItem) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProviderProfileImportItem) ProtoMessage() {} + +func (x *ProviderProfileImportItem) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[79] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProviderProfileImportItem.ProtoReflect.Descriptor instead. +func (*ProviderProfileImportItem) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{79} +} + +func (x *ProviderProfileImportItem) GetProfile() *ProviderProfile { + if x != nil { + return x.Profile + } + return nil +} + +func (x *ProviderProfileImportItem) GetSource() string { + if x != nil { + return x.Source + } + return "" +} + +// Provider profile validation diagnostic. +type ProviderProfileDiagnostic struct { + state protoimpl.MessageState `protogen:"open.v1"` + Source string `protobuf:"bytes,1,opt,name=source,proto3" json:"source,omitempty"` + ProfileId string `protobuf:"bytes,2,opt,name=profile_id,json=profileId,proto3" json:"profile_id,omitempty"` + Field string `protobuf:"bytes,3,opt,name=field,proto3" json:"field,omitempty"` + Message string `protobuf:"bytes,4,opt,name=message,proto3" json:"message,omitempty"` + Severity string `protobuf:"bytes,5,opt,name=severity,proto3" json:"severity,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ProviderProfileDiagnostic) Reset() { + *x = ProviderProfileDiagnostic{} + mi := &file_openshell_proto_msgTypes[80] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ProviderProfileDiagnostic) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProviderProfileDiagnostic) ProtoMessage() {} + +func (x *ProviderProfileDiagnostic) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[80] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProviderProfileDiagnostic.ProtoReflect.Descriptor instead. +func (*ProviderProfileDiagnostic) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{80} +} + +func (x *ProviderProfileDiagnostic) GetSource() string { + if x != nil { + return x.Source + } + return "" +} + +func (x *ProviderProfileDiagnostic) GetProfileId() string { + if x != nil { + return x.ProfileId + } + return "" +} + +func (x *ProviderProfileDiagnostic) GetField() string { + if x != nil { + return x.Field + } + return "" +} + +func (x *ProviderProfileDiagnostic) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +func (x *ProviderProfileDiagnostic) GetSeverity() string { + if x != nil { + return x.Severity + } + return "" +} + +// Endpoint selector for token grant audience overrides. +type ProviderCredentialTokenGrantAudienceOverride struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Optional: endpoint host selector. If omitted, inherits the profile endpoint host. + Host string `protobuf:"bytes,1,opt,name=host,proto3" json:"host,omitempty"` + // Optional: endpoint port selector. If omitted, matches the expanded profile endpoint port. + Port uint32 `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"` + // Optional: endpoint path selector. If omitted, inherits the profile endpoint path. + Path string `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"` + // Resource audience to request for matching endpoints. + Audience string `protobuf:"bytes,4,opt,name=audience,proto3" json:"audience,omitempty"` + // Optional: OAuth2 scopes to request. If omitted, inherits the token grant scopes. + Scopes []string `protobuf:"bytes,5,rep,name=scopes,proto3" json:"scopes,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ProviderCredentialTokenGrantAudienceOverride) Reset() { + *x = ProviderCredentialTokenGrantAudienceOverride{} + mi := &file_openshell_proto_msgTypes[81] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ProviderCredentialTokenGrantAudienceOverride) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProviderCredentialTokenGrantAudienceOverride) ProtoMessage() {} + +func (x *ProviderCredentialTokenGrantAudienceOverride) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[81] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProviderCredentialTokenGrantAudienceOverride.ProtoReflect.Descriptor instead. +func (*ProviderCredentialTokenGrantAudienceOverride) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{81} +} + +func (x *ProviderCredentialTokenGrantAudienceOverride) GetHost() string { + if x != nil { + return x.Host + } + return "" +} + +func (x *ProviderCredentialTokenGrantAudienceOverride) GetPort() uint32 { + if x != nil { + return x.Port + } + return 0 +} + +func (x *ProviderCredentialTokenGrantAudienceOverride) GetPath() string { + if x != nil { + return x.Path + } + return "" +} + +func (x *ProviderCredentialTokenGrantAudienceOverride) GetAudience() string { + if x != nil { + return x.Audience + } + return "" +} + +func (x *ProviderCredentialTokenGrantAudienceOverride) GetScopes() []string { + if x != nil { + return x.Scopes + } + return nil +} + +type ProviderCredentialTokenGrantSubjectToken struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Source for the token exchange subject token. Phase one supports + // "provider_credential". + Source string `protobuf:"bytes,1,opt,name=source,proto3" json:"source,omitempty"` + // Provider credential key that stores the subject token. + Credential string `protobuf:"bytes,2,opt,name=credential,proto3" json:"credential,omitempty"` + // OAuth2 subject_token_type. If omitted, OpenShell uses + // urn:ietf:params:oauth:token-type:access_token. + SubjectTokenType string `protobuf:"bytes,3,opt,name=subject_token_type,json=subjectTokenType,proto3" json:"subject_token_type,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ProviderCredentialTokenGrantSubjectToken) Reset() { + *x = ProviderCredentialTokenGrantSubjectToken{} + mi := &file_openshell_proto_msgTypes[82] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ProviderCredentialTokenGrantSubjectToken) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProviderCredentialTokenGrantSubjectToken) ProtoMessage() {} + +func (x *ProviderCredentialTokenGrantSubjectToken) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[82] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProviderCredentialTokenGrantSubjectToken.ProtoReflect.Descriptor instead. +func (*ProviderCredentialTokenGrantSubjectToken) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{82} +} + +func (x *ProviderCredentialTokenGrantSubjectToken) GetSource() string { + if x != nil { + return x.Source + } + return "" +} + +func (x *ProviderCredentialTokenGrantSubjectToken) GetCredential() string { + if x != nil { + return x.Credential + } + return "" +} + +func (x *ProviderCredentialTokenGrantSubjectToken) GetSubjectTokenType() string { + if x != nil { + return x.SubjectTokenType + } + return "" +} + +type ProviderCredentialTokenGrant struct { + state protoimpl.MessageState `protogen:"open.v1"` + // OAuth2 token endpoint URL (e.g., https://keycloak.example.com/realms/my-realm/protocol/openid-connect/token) + TokenEndpoint string `protobuf:"bytes,1,opt,name=token_endpoint,json=tokenEndpoint,proto3" json:"token_endpoint,omitempty"` + // Optional: default resource audience to request from the token service + Audience string `protobuf:"bytes,2,opt,name=audience,proto3" json:"audience,omitempty"` + // Optional: audience to request when fetching the JWT-SVID from SPIRE. + // If omitted, the sandbox derives this from token_endpoint. + JwtSvidAudience string `protobuf:"bytes,6,opt,name=jwt_svid_audience,json=jwtSvidAudience,proto3" json:"jwt_svid_audience,omitempty"` + // Optional: OAuth2 scopes to request + Scopes []string `protobuf:"bytes,3,rep,name=scopes,proto3" json:"scopes,omitempty"` + // Optional: override token cache TTL (seconds) + // If 0 or omitted, use expires_in from token response + CacheTtlSeconds int64 `protobuf:"varint,4,opt,name=cache_ttl_seconds,json=cacheTtlSeconds,proto3" json:"cache_ttl_seconds,omitempty"` + // Optional: endpoint-specific resource audience overrides. + AudienceOverrides []*ProviderCredentialTokenGrantAudienceOverride `protobuf:"bytes,5,rep,name=audience_overrides,json=audienceOverrides,proto3" json:"audience_overrides,omitempty"` + // Optional: OAuth2 client_assertion_type value. If omitted, OpenShell uses + // urn:ietf:params:oauth:client-assertion-type:jwt-bearer. + ClientAssertionType string `protobuf:"bytes,7,opt,name=client_assertion_type,json=clientAssertionType,proto3" json:"client_assertion_type,omitempty"` + // Grant type. If omitted/unspecified, OpenShell treats this as client_credentials + // for backwards compatibility. + GrantType ProviderCredentialTokenGrantType `protobuf:"varint,8,opt,name=grant_type,json=grantType,proto3,enum=openshell.v1.ProviderCredentialTokenGrantType" json:"grant_type,omitempty"` + // Subject token metadata for token_exchange grants. + SubjectToken *ProviderCredentialTokenGrantSubjectToken `protobuf:"bytes,9,opt,name=subject_token,json=subjectToken,proto3" json:"subject_token,omitempty"` + // OAuth2 requested_token_type. If omitted for token_exchange, OpenShell uses + // urn:ietf:params:oauth:token-type:access_token. + RequestedTokenType string `protobuf:"bytes,10,opt,name=requested_token_type,json=requestedTokenType,proto3" json:"requested_token_type,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ProviderCredentialTokenGrant) Reset() { + *x = ProviderCredentialTokenGrant{} + mi := &file_openshell_proto_msgTypes[83] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ProviderCredentialTokenGrant) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProviderCredentialTokenGrant) ProtoMessage() {} + +func (x *ProviderCredentialTokenGrant) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[83] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProviderCredentialTokenGrant.ProtoReflect.Descriptor instead. +func (*ProviderCredentialTokenGrant) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{83} +} + +func (x *ProviderCredentialTokenGrant) GetTokenEndpoint() string { + if x != nil { + return x.TokenEndpoint + } + return "" +} + +func (x *ProviderCredentialTokenGrant) GetAudience() string { + if x != nil { + return x.Audience + } + return "" +} + +func (x *ProviderCredentialTokenGrant) GetJwtSvidAudience() string { + if x != nil { + return x.JwtSvidAudience + } + return "" +} + +func (x *ProviderCredentialTokenGrant) GetScopes() []string { + if x != nil { + return x.Scopes + } + return nil +} + +func (x *ProviderCredentialTokenGrant) GetCacheTtlSeconds() int64 { + if x != nil { + return x.CacheTtlSeconds + } + return 0 +} + +func (x *ProviderCredentialTokenGrant) GetAudienceOverrides() []*ProviderCredentialTokenGrantAudienceOverride { + if x != nil { + return x.AudienceOverrides + } + return nil +} + +func (x *ProviderCredentialTokenGrant) GetClientAssertionType() string { + if x != nil { + return x.ClientAssertionType + } + return "" +} + +func (x *ProviderCredentialTokenGrant) GetGrantType() ProviderCredentialTokenGrantType { + if x != nil { + return x.GrantType + } + return ProviderCredentialTokenGrantType_PROVIDER_CREDENTIAL_TOKEN_GRANT_TYPE_UNSPECIFIED +} + +func (x *ProviderCredentialTokenGrant) GetSubjectToken() *ProviderCredentialTokenGrantSubjectToken { + if x != nil { + return x.SubjectToken + } + return nil +} + +func (x *ProviderCredentialTokenGrant) GetRequestedTokenType() string { + if x != nil { + return x.RequestedTokenType + } + return "" +} + +// Provider credential declaration. +type ProviderProfileCredential struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` + EnvVars []string `protobuf:"bytes,3,rep,name=env_vars,json=envVars,proto3" json:"env_vars,omitempty"` + Required bool `protobuf:"varint,4,opt,name=required,proto3" json:"required,omitempty"` + AuthStyle string `protobuf:"bytes,5,opt,name=auth_style,json=authStyle,proto3" json:"auth_style,omitempty"` + HeaderName string `protobuf:"bytes,6,opt,name=header_name,json=headerName,proto3" json:"header_name,omitempty"` + QueryParam string `protobuf:"bytes,7,opt,name=query_param,json=queryParam,proto3" json:"query_param,omitempty"` + Refresh *ProviderCredentialRefresh `protobuf:"bytes,8,opt,name=refresh,proto3" json:"refresh,omitempty"` + PathTemplate string `protobuf:"bytes,9,opt,name=path_template,json=pathTemplate,proto3" json:"path_template,omitempty"` + TokenGrant *ProviderCredentialTokenGrant `protobuf:"bytes,10,opt,name=token_grant,json=tokenGrant,proto3" json:"token_grant,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ProviderProfileCredential) Reset() { + *x = ProviderProfileCredential{} + mi := &file_openshell_proto_msgTypes[84] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ProviderProfileCredential) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProviderProfileCredential) ProtoMessage() {} + +func (x *ProviderProfileCredential) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[84] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProviderProfileCredential.ProtoReflect.Descriptor instead. +func (*ProviderProfileCredential) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{84} +} + +func (x *ProviderProfileCredential) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *ProviderProfileCredential) GetDescription() string { + if x != nil { + return x.Description + } + return "" +} + +func (x *ProviderProfileCredential) GetEnvVars() []string { + if x != nil { + return x.EnvVars + } + return nil +} + +func (x *ProviderProfileCredential) GetRequired() bool { + if x != nil { + return x.Required + } + return false +} + +func (x *ProviderProfileCredential) GetAuthStyle() string { + if x != nil { + return x.AuthStyle + } + return "" +} + +func (x *ProviderProfileCredential) GetHeaderName() string { + if x != nil { + return x.HeaderName + } + return "" +} + +func (x *ProviderProfileCredential) GetQueryParam() string { + if x != nil { + return x.QueryParam + } + return "" +} + +func (x *ProviderProfileCredential) GetRefresh() *ProviderCredentialRefresh { + if x != nil { + return x.Refresh + } + return nil +} + +func (x *ProviderProfileCredential) GetPathTemplate() string { + if x != nil { + return x.PathTemplate + } + return "" +} + +func (x *ProviderProfileCredential) GetTokenGrant() *ProviderCredentialTokenGrant { + if x != nil { + return x.TokenGrant + } + return nil +} + +type ProviderCredentialRefreshMaterial struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` + Required bool `protobuf:"varint,3,opt,name=required,proto3" json:"required,omitempty"` + Secret bool `protobuf:"varint,4,opt,name=secret,proto3" json:"secret,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ProviderCredentialRefreshMaterial) Reset() { + *x = ProviderCredentialRefreshMaterial{} + mi := &file_openshell_proto_msgTypes[85] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ProviderCredentialRefreshMaterial) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProviderCredentialRefreshMaterial) ProtoMessage() {} + +func (x *ProviderCredentialRefreshMaterial) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[85] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProviderCredentialRefreshMaterial.ProtoReflect.Descriptor instead. +func (*ProviderCredentialRefreshMaterial) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{85} +} + +func (x *ProviderCredentialRefreshMaterial) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *ProviderCredentialRefreshMaterial) GetDescription() string { + if x != nil { + return x.Description + } + return "" +} + +func (x *ProviderCredentialRefreshMaterial) GetRequired() bool { + if x != nil { + return x.Required + } + return false +} + +func (x *ProviderCredentialRefreshMaterial) GetSecret() bool { + if x != nil { + return x.Secret + } + return false +} + +// Declares that a single refresh operation mints more than one credential. +// The refresh is attached to a primary credential; each additional output +// maps a strategy-defined semantic output id to a sibling credential whose +// env_vars receive the minted value. +type ProviderCredentialRefreshOutput struct { + state protoimpl.MessageState `protogen:"open.v1"` + Output string `protobuf:"bytes,1,opt,name=output,proto3" json:"output,omitempty"` // strategy-defined semantic output id (e.g. "session_token") + Credential string `protobuf:"bytes,2,opt,name=credential,proto3" json:"credential,omitempty"` // sibling credential name whose env_vars receive this output + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ProviderCredentialRefreshOutput) Reset() { + *x = ProviderCredentialRefreshOutput{} + mi := &file_openshell_proto_msgTypes[86] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ProviderCredentialRefreshOutput) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProviderCredentialRefreshOutput) ProtoMessage() {} + +func (x *ProviderCredentialRefreshOutput) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[86] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProviderCredentialRefreshOutput.ProtoReflect.Descriptor instead. +func (*ProviderCredentialRefreshOutput) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{86} +} + +func (x *ProviderCredentialRefreshOutput) GetOutput() string { + if x != nil { + return x.Output + } + return "" +} + +func (x *ProviderCredentialRefreshOutput) GetCredential() string { + if x != nil { + return x.Credential + } + return "" +} + +type ProviderCredentialRefresh struct { + state protoimpl.MessageState `protogen:"open.v1"` + Strategy ProviderCredentialRefreshStrategy `protobuf:"varint,1,opt,name=strategy,proto3,enum=openshell.v1.ProviderCredentialRefreshStrategy" json:"strategy,omitempty"` + TokenUrl string `protobuf:"bytes,2,opt,name=token_url,json=tokenUrl,proto3" json:"token_url,omitempty"` + Scopes []string `protobuf:"bytes,3,rep,name=scopes,proto3" json:"scopes,omitempty"` + RefreshBeforeSeconds int64 `protobuf:"varint,4,opt,name=refresh_before_seconds,json=refreshBeforeSeconds,proto3" json:"refresh_before_seconds,omitempty"` + MaxLifetimeSeconds int64 `protobuf:"varint,5,opt,name=max_lifetime_seconds,json=maxLifetimeSeconds,proto3" json:"max_lifetime_seconds,omitempty"` + Material []*ProviderCredentialRefreshMaterial `protobuf:"bytes,6,rep,name=material,proto3" json:"material,omitempty"` + AdditionalOutputs []*ProviderCredentialRefreshOutput `protobuf:"bytes,7,rep,name=additional_outputs,json=additionalOutputs,proto3" json:"additional_outputs,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ProviderCredentialRefresh) Reset() { + *x = ProviderCredentialRefresh{} + mi := &file_openshell_proto_msgTypes[87] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ProviderCredentialRefresh) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProviderCredentialRefresh) ProtoMessage() {} + +func (x *ProviderCredentialRefresh) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[87] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProviderCredentialRefresh.ProtoReflect.Descriptor instead. +func (*ProviderCredentialRefresh) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{87} +} + +func (x *ProviderCredentialRefresh) GetStrategy() ProviderCredentialRefreshStrategy { + if x != nil { + return x.Strategy + } + return ProviderCredentialRefreshStrategy_PROVIDER_CREDENTIAL_REFRESH_STRATEGY_UNSPECIFIED +} + +func (x *ProviderCredentialRefresh) GetTokenUrl() string { + if x != nil { + return x.TokenUrl + } + return "" +} + +func (x *ProviderCredentialRefresh) GetScopes() []string { + if x != nil { + return x.Scopes + } + return nil +} + +func (x *ProviderCredentialRefresh) GetRefreshBeforeSeconds() int64 { + if x != nil { + return x.RefreshBeforeSeconds + } + return 0 +} + +func (x *ProviderCredentialRefresh) GetMaxLifetimeSeconds() int64 { + if x != nil { + return x.MaxLifetimeSeconds + } + return 0 +} + +func (x *ProviderCredentialRefresh) GetMaterial() []*ProviderCredentialRefreshMaterial { + if x != nil { + return x.Material + } + return nil +} + +func (x *ProviderCredentialRefresh) GetAdditionalOutputs() []*ProviderCredentialRefreshOutput { + if x != nil { + return x.AdditionalOutputs + } + return nil +} + +type ProviderCredentialRefreshStatus struct { + state protoimpl.MessageState `protogen:"open.v1"` + ProviderName string `protobuf:"bytes,1,opt,name=provider_name,json=providerName,proto3" json:"provider_name,omitempty"` + ProviderId string `protobuf:"bytes,2,opt,name=provider_id,json=providerId,proto3" json:"provider_id,omitempty"` + CredentialKey string `protobuf:"bytes,3,opt,name=credential_key,json=credentialKey,proto3" json:"credential_key,omitempty"` + Strategy ProviderCredentialRefreshStrategy `protobuf:"varint,4,opt,name=strategy,proto3,enum=openshell.v1.ProviderCredentialRefreshStrategy" json:"strategy,omitempty"` + Status string `protobuf:"bytes,5,opt,name=status,proto3" json:"status,omitempty"` + ExpiresAtMs int64 `protobuf:"varint,6,opt,name=expires_at_ms,json=expiresAtMs,proto3" json:"expires_at_ms,omitempty"` + // Next automatic refresh time in Unix epoch milliseconds. A value of + // 9223372036854775807 (int64 max) means no automatic retry is scheduled; + // consumers should render it as unset and use recovery_action to determine + // the required recovery workflow. + NextRefreshAtMs int64 `protobuf:"varint,7,opt,name=next_refresh_at_ms,json=nextRefreshAtMs,proto3" json:"next_refresh_at_ms,omitempty"` + LastRefreshAtMs int64 `protobuf:"varint,8,opt,name=last_refresh_at_ms,json=lastRefreshAtMs,proto3" json:"last_refresh_at_ms,omitempty"` + LastError string `protobuf:"bytes,9,opt,name=last_error,json=lastError,proto3" json:"last_error,omitempty"` + RecoveryAction ProviderCredentialRefreshRecoveryAction `protobuf:"varint,10,opt,name=recovery_action,json=recoveryAction,proto3,enum=openshell.v1.ProviderCredentialRefreshRecoveryAction" json:"recovery_action,omitempty"` + // Stable gateway-owned failure identifier, for example + // "oauth_invalid_grant". This is not provider-controlled prose and + // incorporates any recognized top-level OAuth error classification. + FailureCode string `protobuf:"bytes,11,opt,name=failure_code,json=failureCode,proto3" json:"failure_code,omitempty"` + // A bounded, recognized provider subtype that refines failure_code; clients + // do not need a separate provider_error field. Unknown provider-controlled + // values are not persisted or returned. + ProviderErrorSubtype string `protobuf:"bytes,12,opt,name=provider_error_subtype,json=providerErrorSubtype,proto3" json:"provider_error_subtype,omitempty"` + LastErrorAtMs int64 `protobuf:"varint,13,opt,name=last_error_at_ms,json=lastErrorAtMs,proto3" json:"last_error_at_ms,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ProviderCredentialRefreshStatus) Reset() { + *x = ProviderCredentialRefreshStatus{} + mi := &file_openshell_proto_msgTypes[88] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ProviderCredentialRefreshStatus) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProviderCredentialRefreshStatus) ProtoMessage() {} + +func (x *ProviderCredentialRefreshStatus) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[88] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProviderCredentialRefreshStatus.ProtoReflect.Descriptor instead. +func (*ProviderCredentialRefreshStatus) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{88} +} + +func (x *ProviderCredentialRefreshStatus) GetProviderName() string { + if x != nil { + return x.ProviderName + } + return "" +} + +func (x *ProviderCredentialRefreshStatus) GetProviderId() string { + if x != nil { + return x.ProviderId + } + return "" +} + +func (x *ProviderCredentialRefreshStatus) GetCredentialKey() string { + if x != nil { + return x.CredentialKey + } + return "" +} + +func (x *ProviderCredentialRefreshStatus) GetStrategy() ProviderCredentialRefreshStrategy { + if x != nil { + return x.Strategy + } + return ProviderCredentialRefreshStrategy_PROVIDER_CREDENTIAL_REFRESH_STRATEGY_UNSPECIFIED +} + +func (x *ProviderCredentialRefreshStatus) GetStatus() string { + if x != nil { + return x.Status + } + return "" +} + +func (x *ProviderCredentialRefreshStatus) GetExpiresAtMs() int64 { + if x != nil { + return x.ExpiresAtMs + } + return 0 +} + +func (x *ProviderCredentialRefreshStatus) GetNextRefreshAtMs() int64 { + if x != nil { + return x.NextRefreshAtMs + } + return 0 +} + +func (x *ProviderCredentialRefreshStatus) GetLastRefreshAtMs() int64 { + if x != nil { + return x.LastRefreshAtMs + } + return 0 +} + +func (x *ProviderCredentialRefreshStatus) GetLastError() string { + if x != nil { + return x.LastError + } + return "" +} + +func (x *ProviderCredentialRefreshStatus) GetRecoveryAction() ProviderCredentialRefreshRecoveryAction { + if x != nil { + return x.RecoveryAction + } + return ProviderCredentialRefreshRecoveryAction_PROVIDER_CREDENTIAL_REFRESH_RECOVERY_ACTION_UNSPECIFIED +} + +func (x *ProviderCredentialRefreshStatus) GetFailureCode() string { + if x != nil { + return x.FailureCode + } + return "" +} + +func (x *ProviderCredentialRefreshStatus) GetProviderErrorSubtype() string { + if x != nil { + return x.ProviderErrorSubtype + } + return "" +} + +func (x *ProviderCredentialRefreshStatus) GetLastErrorAtMs() int64 { + if x != nil { + return x.LastErrorAtMs + } + return 0 +} + +// Provider profile local discovery declaration. +type ProviderProfileDiscovery struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Credential names from ProviderProfile.credentials eligible for local discovery. + Credentials []string `protobuf:"bytes,1,rep,name=credentials,proto3" json:"credentials,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ProviderProfileDiscovery) Reset() { + *x = ProviderProfileDiscovery{} + mi := &file_openshell_proto_msgTypes[89] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ProviderProfileDiscovery) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProviderProfileDiscovery) ProtoMessage() {} + +func (x *ProviderProfileDiscovery) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[89] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProviderProfileDiscovery.ProtoReflect.Descriptor instead. +func (*ProviderProfileDiscovery) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{89} +} + +func (x *ProviderProfileDiscovery) GetCredentials() []string { + if x != nil { + return x.Credentials + } + return nil +} + +type StoredProviderCredentialRefreshState struct { + state protoimpl.MessageState `protogen:"open.v1"` + Metadata *datamodelv1.ObjectMeta `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"` + ProviderId string `protobuf:"bytes,2,opt,name=provider_id,json=providerId,proto3" json:"provider_id,omitempty"` + ProviderName string `protobuf:"bytes,3,opt,name=provider_name,json=providerName,proto3" json:"provider_name,omitempty"` + CredentialKey string `protobuf:"bytes,4,opt,name=credential_key,json=credentialKey,proto3" json:"credential_key,omitempty"` + Strategy ProviderCredentialRefreshStrategy `protobuf:"varint,5,opt,name=strategy,proto3,enum=openshell.v1.ProviderCredentialRefreshStrategy" json:"strategy,omitempty"` + Material map[string]string `protobuf:"bytes,6,rep,name=material,proto3" json:"material,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + // Material names classified as secret. Newly configured values live in the + // active credential driver and are absent from material. Legacy inline values + // are not automatically migrated before OpenShell 0.1.0. + SecretMaterialKeys []string `protobuf:"bytes,7,rep,name=secret_material_keys,json=secretMaterialKeys,proto3" json:"secret_material_keys,omitempty"` + ExpiresAtMs int64 `protobuf:"varint,8,opt,name=expires_at_ms,json=expiresAtMs,proto3" json:"expires_at_ms,omitempty"` + // int64 max parks the refresh until an explicit rotation or reconfiguration. + NextRefreshAtMs int64 `protobuf:"varint,9,opt,name=next_refresh_at_ms,json=nextRefreshAtMs,proto3" json:"next_refresh_at_ms,omitempty"` + LastRefreshAtMs int64 `protobuf:"varint,10,opt,name=last_refresh_at_ms,json=lastRefreshAtMs,proto3" json:"last_refresh_at_ms,omitempty"` + Status string `protobuf:"bytes,11,opt,name=status,proto3" json:"status,omitempty"` + LastError string `protobuf:"bytes,12,opt,name=last_error,json=lastError,proto3" json:"last_error,omitempty"` + TokenUrl string `protobuf:"bytes,13,opt,name=token_url,json=tokenUrl,proto3" json:"token_url,omitempty"` + Scopes []string `protobuf:"bytes,14,rep,name=scopes,proto3" json:"scopes,omitempty"` + RefreshBeforeSeconds int64 `protobuf:"varint,15,opt,name=refresh_before_seconds,json=refreshBeforeSeconds,proto3" json:"refresh_before_seconds,omitempty"` + MaxLifetimeSeconds int64 `protobuf:"varint,16,opt,name=max_lifetime_seconds,json=maxLifetimeSeconds,proto3" json:"max_lifetime_seconds,omitempty"` + // Resolved mapping of strategy-defined output id -> concrete env key, pinned + // at configure time from the profile's additional_outputs. Read by minting, + // collision reservation, and env-key surfacing so later profile edits cannot + // silently redirect writes. + AdditionalOutputKeys map[string]string `protobuf:"bytes,17,rep,name=additional_output_keys,json=additionalOutputKeys,proto3" json:"additional_output_keys,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + // Opaque gateway-owned authorization epoch for the configured refresh + // grant. Explicit refresh configuration creates a new epoch; automatic and + // manual token rotation preserve it. It is never derived from or exposed + // with refresh material. + AuthorizationEpoch string `protobuf:"bytes,18,opt,name=authorization_epoch,json=authorizationEpoch,proto3" json:"authorization_epoch,omitempty"` + // Secret refresh material is stored through the gateway's active credential + // driver. The persisted refresh state keeps only opaque handles; resolved + // values exist in gateway memory for the duration of one mint operation. + SecretMaterialHandles map[string]*datamodelv1.CredentialHandle `protobuf:"bytes,19,rep,name=secret_material_handles,json=secretMaterialHandles,proto3" json:"secret_material_handles,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + // Handles replaced by reconfiguration or issuer-driven refresh-token + // rotation. This is a repeated entry rather than a material-keyed map so + // multiple superseded generations of the same material remain recoverable. + // Cleanup is retried by the refresh worker so a gateway crash or temporary + // credential-backend outage does not lose the deletion reference. + PendingSecretDeletions []*StoredRefreshMaterialDeletion `protobuf:"bytes,20,rep,name=pending_secret_deletions,json=pendingSecretDeletions,proto3" json:"pending_secret_deletions,omitempty"` + // Structured recovery details for the most recent refresh failure. These + // fields contain only gateway-owned codes and recognized bounded values. + RecoveryAction ProviderCredentialRefreshRecoveryAction `protobuf:"varint,21,opt,name=recovery_action,json=recoveryAction,proto3,enum=openshell.v1.ProviderCredentialRefreshRecoveryAction" json:"recovery_action,omitempty"` + FailureCode string `protobuf:"bytes,22,opt,name=failure_code,json=failureCode,proto3" json:"failure_code,omitempty"` + ProviderErrorSubtype string `protobuf:"bytes,23,opt,name=provider_error_subtype,json=providerErrorSubtype,proto3" json:"provider_error_subtype,omitempty"` + LastErrorAtMs int64 `protobuf:"varint,24,opt,name=last_error_at_ms,json=lastErrorAtMs,proto3" json:"last_error_at_ms,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *StoredProviderCredentialRefreshState) Reset() { + *x = StoredProviderCredentialRefreshState{} + mi := &file_openshell_proto_msgTypes[90] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *StoredProviderCredentialRefreshState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StoredProviderCredentialRefreshState) ProtoMessage() {} + +func (x *StoredProviderCredentialRefreshState) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[90] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use StoredProviderCredentialRefreshState.ProtoReflect.Descriptor instead. +func (*StoredProviderCredentialRefreshState) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{90} +} + +func (x *StoredProviderCredentialRefreshState) GetMetadata() *datamodelv1.ObjectMeta { + if x != nil { + return x.Metadata + } + return nil +} + +func (x *StoredProviderCredentialRefreshState) GetProviderId() string { + if x != nil { + return x.ProviderId + } + return "" +} + +func (x *StoredProviderCredentialRefreshState) GetProviderName() string { + if x != nil { + return x.ProviderName + } + return "" +} + +func (x *StoredProviderCredentialRefreshState) GetCredentialKey() string { + if x != nil { + return x.CredentialKey + } + return "" +} + +func (x *StoredProviderCredentialRefreshState) GetStrategy() ProviderCredentialRefreshStrategy { + if x != nil { + return x.Strategy + } + return ProviderCredentialRefreshStrategy_PROVIDER_CREDENTIAL_REFRESH_STRATEGY_UNSPECIFIED } -func (x *ProviderProfileCredential) GetDescription() string { +func (x *StoredProviderCredentialRefreshState) GetMaterial() map[string]string { if x != nil { - return x.Description + return x.Material } - return "" + return nil } -func (x *ProviderProfileCredential) GetEnvVars() []string { +func (x *StoredProviderCredentialRefreshState) GetSecretMaterialKeys() []string { if x != nil { - return x.EnvVars + return x.SecretMaterialKeys } return nil } -func (x *ProviderProfileCredential) GetRequired() bool { +func (x *StoredProviderCredentialRefreshState) GetExpiresAtMs() int64 { if x != nil { - return x.Required + return x.ExpiresAtMs } - return false + return 0 } -func (x *ProviderProfileCredential) GetAuthStyle() string { +func (x *StoredProviderCredentialRefreshState) GetNextRefreshAtMs() int64 { if x != nil { - return x.AuthStyle + return x.NextRefreshAtMs } - return "" + return 0 } -func (x *ProviderProfileCredential) GetHeaderName() string { +func (x *StoredProviderCredentialRefreshState) GetLastRefreshAtMs() int64 { if x != nil { - return x.HeaderName + return x.LastRefreshAtMs } - return "" + return 0 } -func (x *ProviderProfileCredential) GetQueryParam() string { +func (x *StoredProviderCredentialRefreshState) GetStatus() string { if x != nil { - return x.QueryParam + return x.Status } return "" } -func (x *ProviderProfileCredential) GetRefresh() *ProviderCredentialRefresh { +func (x *StoredProviderCredentialRefreshState) GetLastError() string { if x != nil { - return x.Refresh + return x.LastError } - return nil + return "" } -func (x *ProviderProfileCredential) GetPathTemplate() string { +func (x *StoredProviderCredentialRefreshState) GetTokenUrl() string { if x != nil { - return x.PathTemplate + return x.TokenUrl } return "" } -func (x *ProviderProfileCredential) GetTokenGrant() *ProviderCredentialTokenGrant { +func (x *StoredProviderCredentialRefreshState) GetScopes() []string { if x != nil { - return x.TokenGrant + return x.Scopes } return nil } -type ProviderCredentialRefreshMaterial struct { - state protoimpl.MessageState `protogen:"open.v1"` - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` - Required bool `protobuf:"varint,3,opt,name=required,proto3" json:"required,omitempty"` - Secret bool `protobuf:"varint,4,opt,name=secret,proto3" json:"secret,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +func (x *StoredProviderCredentialRefreshState) GetRefreshBeforeSeconds() int64 { + if x != nil { + return x.RefreshBeforeSeconds + } + return 0 } -func (x *ProviderCredentialRefreshMaterial) Reset() { - *x = ProviderCredentialRefreshMaterial{} - mi := &file_openshell_proto_msgTypes[76] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) +func (x *StoredProviderCredentialRefreshState) GetMaxLifetimeSeconds() int64 { + if x != nil { + return x.MaxLifetimeSeconds + } + return 0 } -func (x *ProviderCredentialRefreshMaterial) String() string { - return protoimpl.X.MessageStringOf(x) +func (x *StoredProviderCredentialRefreshState) GetAdditionalOutputKeys() map[string]string { + if x != nil { + return x.AdditionalOutputKeys + } + return nil } -func (*ProviderCredentialRefreshMaterial) ProtoMessage() {} +func (x *StoredProviderCredentialRefreshState) GetAuthorizationEpoch() string { + if x != nil { + return x.AuthorizationEpoch + } + return "" +} -func (x *ProviderCredentialRefreshMaterial) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[76] +func (x *StoredProviderCredentialRefreshState) GetSecretMaterialHandles() map[string]*datamodelv1.CredentialHandle { if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms + return x.SecretMaterialHandles } - return mi.MessageOf(x) + return nil } -// Deprecated: Use ProviderCredentialRefreshMaterial.ProtoReflect.Descriptor instead. -func (*ProviderCredentialRefreshMaterial) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{76} +func (x *StoredProviderCredentialRefreshState) GetPendingSecretDeletions() []*StoredRefreshMaterialDeletion { + if x != nil { + return x.PendingSecretDeletions + } + return nil } -func (x *ProviderCredentialRefreshMaterial) GetName() string { +func (x *StoredProviderCredentialRefreshState) GetRecoveryAction() ProviderCredentialRefreshRecoveryAction { if x != nil { - return x.Name + return x.RecoveryAction } - return "" + return ProviderCredentialRefreshRecoveryAction_PROVIDER_CREDENTIAL_REFRESH_RECOVERY_ACTION_UNSPECIFIED } -func (x *ProviderCredentialRefreshMaterial) GetDescription() string { +func (x *StoredProviderCredentialRefreshState) GetFailureCode() string { if x != nil { - return x.Description + return x.FailureCode } return "" } -func (x *ProviderCredentialRefreshMaterial) GetRequired() bool { +func (x *StoredProviderCredentialRefreshState) GetProviderErrorSubtype() string { if x != nil { - return x.Required + return x.ProviderErrorSubtype } - return false + return "" } -func (x *ProviderCredentialRefreshMaterial) GetSecret() bool { +func (x *StoredProviderCredentialRefreshState) GetLastErrorAtMs() int64 { if x != nil { - return x.Secret + return x.LastErrorAtMs } - return false + return 0 } -// Declares that a single refresh operation mints more than one credential. -// The refresh is attached to a primary credential; each additional output -// maps a strategy-defined semantic output id to a sibling credential whose -// env_vars receive the minted value. -type ProviderCredentialRefreshOutput struct { - state protoimpl.MessageState `protogen:"open.v1"` - Output string `protobuf:"bytes,1,opt,name=output,proto3" json:"output,omitempty"` // strategy-defined semantic output id (e.g. "session_token") - Credential string `protobuf:"bytes,2,opt,name=credential,proto3" json:"credential,omitempty"` // sibling credential name whose env_vars receive this output +type StoredRefreshMaterialDeletion struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Original material name used to derive the credential driver's storage key. + MaterialKey string `protobuf:"bytes,1,opt,name=material_key,json=materialKey,proto3" json:"material_key,omitempty"` + // Opaque handle for the superseded secret object. + Handle *datamodelv1.CredentialHandle `protobuf:"bytes,2,opt,name=handle,proto3" json:"handle,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ProviderCredentialRefreshOutput) Reset() { - *x = ProviderCredentialRefreshOutput{} - mi := &file_openshell_proto_msgTypes[77] +func (x *StoredRefreshMaterialDeletion) Reset() { + *x = StoredRefreshMaterialDeletion{} + mi := &file_openshell_proto_msgTypes[91] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ProviderCredentialRefreshOutput) String() string { +func (x *StoredRefreshMaterialDeletion) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ProviderCredentialRefreshOutput) ProtoMessage() {} +func (*StoredRefreshMaterialDeletion) ProtoMessage() {} -func (x *ProviderCredentialRefreshOutput) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[77] +func (x *StoredRefreshMaterialDeletion) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[91] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5825,53 +6976,57 @@ func (x *ProviderCredentialRefreshOutput) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ProviderCredentialRefreshOutput.ProtoReflect.Descriptor instead. -func (*ProviderCredentialRefreshOutput) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{77} +// Deprecated: Use StoredRefreshMaterialDeletion.ProtoReflect.Descriptor instead. +func (*StoredRefreshMaterialDeletion) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{91} } -func (x *ProviderCredentialRefreshOutput) GetOutput() string { +func (x *StoredRefreshMaterialDeletion) GetMaterialKey() string { if x != nil { - return x.Output + return x.MaterialKey } return "" } -func (x *ProviderCredentialRefreshOutput) GetCredential() string { +func (x *StoredRefreshMaterialDeletion) GetHandle() *datamodelv1.CredentialHandle { if x != nil { - return x.Credential + return x.Handle } - return "" -} - -type ProviderCredentialRefresh struct { - state protoimpl.MessageState `protogen:"open.v1"` - Strategy ProviderCredentialRefreshStrategy `protobuf:"varint,1,opt,name=strategy,proto3,enum=openshell.v1.ProviderCredentialRefreshStrategy" json:"strategy,omitempty"` - TokenUrl string `protobuf:"bytes,2,opt,name=token_url,json=tokenUrl,proto3" json:"token_url,omitempty"` - Scopes []string `protobuf:"bytes,3,rep,name=scopes,proto3" json:"scopes,omitempty"` - RefreshBeforeSeconds int64 `protobuf:"varint,4,opt,name=refresh_before_seconds,json=refreshBeforeSeconds,proto3" json:"refresh_before_seconds,omitempty"` - MaxLifetimeSeconds int64 `protobuf:"varint,5,opt,name=max_lifetime_seconds,json=maxLifetimeSeconds,proto3" json:"max_lifetime_seconds,omitempty"` - Material []*ProviderCredentialRefreshMaterial `protobuf:"bytes,6,rep,name=material,proto3" json:"material,omitempty"` - AdditionalOutputs []*ProviderCredentialRefreshOutput `protobuf:"bytes,7,rep,name=additional_outputs,json=additionalOutputs,proto3" json:"additional_outputs,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + return nil } -func (x *ProviderCredentialRefresh) Reset() { - *x = ProviderCredentialRefresh{} - mi := &file_openshell_proto_msgTypes[78] +type DelegatedIdentityCredential struct { + state protoimpl.MessageState `protogen:"open.v1"` + Metadata *datamodelv1.ObjectMeta `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"` + Issuer string `protobuf:"bytes,2,opt,name=issuer,proto3" json:"issuer,omitempty"` + ClientId string `protobuf:"bytes,3,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"` + PrincipalSubject string `protobuf:"bytes,4,opt,name=principal_subject,json=principalSubject,proto3" json:"principal_subject,omitempty"` + RefreshToken string `protobuf:"bytes,5,opt,name=refresh_token,json=refreshToken,proto3" json:"refresh_token,omitempty"` + AccessToken string `protobuf:"bytes,6,opt,name=access_token,json=accessToken,proto3" json:"access_token,omitempty"` + AccessTokenExpiresAtMs int64 `protobuf:"varint,7,opt,name=access_token_expires_at_ms,json=accessTokenExpiresAtMs,proto3" json:"access_token_expires_at_ms,omitempty"` + Scopes string `protobuf:"bytes,8,opt,name=scopes,proto3" json:"scopes,omitempty"` + Audience string `protobuf:"bytes,9,opt,name=audience,proto3" json:"audience,omitempty"` + LastRefreshAtMs int64 `protobuf:"varint,10,opt,name=last_refresh_at_ms,json=lastRefreshAtMs,proto3" json:"last_refresh_at_ms,omitempty"` + RevokedAtMs int64 `protobuf:"varint,11,opt,name=revoked_at_ms,json=revokedAtMs,proto3" json:"revoked_at_ms,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DelegatedIdentityCredential) Reset() { + *x = DelegatedIdentityCredential{} + mi := &file_openshell_proto_msgTypes[92] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ProviderCredentialRefresh) String() string { +func (x *DelegatedIdentityCredential) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ProviderCredentialRefresh) ProtoMessage() {} +func (*DelegatedIdentityCredential) ProtoMessage() {} -func (x *ProviderCredentialRefresh) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[78] +func (x *DelegatedIdentityCredential) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[92] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5882,104 +7037,120 @@ func (x *ProviderCredentialRefresh) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ProviderCredentialRefresh.ProtoReflect.Descriptor instead. -func (*ProviderCredentialRefresh) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{78} +// Deprecated: Use DelegatedIdentityCredential.ProtoReflect.Descriptor instead. +func (*DelegatedIdentityCredential) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{92} } -func (x *ProviderCredentialRefresh) GetStrategy() ProviderCredentialRefreshStrategy { +func (x *DelegatedIdentityCredential) GetMetadata() *datamodelv1.ObjectMeta { if x != nil { - return x.Strategy + return x.Metadata } - return ProviderCredentialRefreshStrategy_PROVIDER_CREDENTIAL_REFRESH_STRATEGY_UNSPECIFIED + return nil } -func (x *ProviderCredentialRefresh) GetTokenUrl() string { +func (x *DelegatedIdentityCredential) GetIssuer() string { if x != nil { - return x.TokenUrl + return x.Issuer } return "" } -func (x *ProviderCredentialRefresh) GetScopes() []string { - if x != nil { - return x.Scopes - } - return nil -} - -func (x *ProviderCredentialRefresh) GetRefreshBeforeSeconds() int64 { +func (x *DelegatedIdentityCredential) GetClientId() string { if x != nil { - return x.RefreshBeforeSeconds + return x.ClientId } - return 0 + return "" } -func (x *ProviderCredentialRefresh) GetMaxLifetimeSeconds() int64 { +func (x *DelegatedIdentityCredential) GetPrincipalSubject() string { if x != nil { - return x.MaxLifetimeSeconds + return x.PrincipalSubject } - return 0 + return "" } -func (x *ProviderCredentialRefresh) GetMaterial() []*ProviderCredentialRefreshMaterial { +func (x *DelegatedIdentityCredential) GetRefreshToken() string { if x != nil { - return x.Material + return x.RefreshToken } - return nil + return "" } -func (x *ProviderCredentialRefresh) GetAdditionalOutputs() []*ProviderCredentialRefreshOutput { +func (x *DelegatedIdentityCredential) GetAccessToken() string { if x != nil { - return x.AdditionalOutputs + return x.AccessToken } - return nil + return "" } -type ProviderCredentialRefreshStatus struct { - state protoimpl.MessageState `protogen:"open.v1"` - ProviderName string `protobuf:"bytes,1,opt,name=provider_name,json=providerName,proto3" json:"provider_name,omitempty"` - ProviderId string `protobuf:"bytes,2,opt,name=provider_id,json=providerId,proto3" json:"provider_id,omitempty"` - CredentialKey string `protobuf:"bytes,3,opt,name=credential_key,json=credentialKey,proto3" json:"credential_key,omitempty"` - Strategy ProviderCredentialRefreshStrategy `protobuf:"varint,4,opt,name=strategy,proto3,enum=openshell.v1.ProviderCredentialRefreshStrategy" json:"strategy,omitempty"` - Status string `protobuf:"bytes,5,opt,name=status,proto3" json:"status,omitempty"` - ExpiresAtMs int64 `protobuf:"varint,6,opt,name=expires_at_ms,json=expiresAtMs,proto3" json:"expires_at_ms,omitempty"` - // Next automatic refresh time in Unix epoch milliseconds. A value of - // 9223372036854775807 (int64 max) means no automatic retry is scheduled; - // consumers should render it as unset and use recovery_action to determine - // the required recovery workflow. - NextRefreshAtMs int64 `protobuf:"varint,7,opt,name=next_refresh_at_ms,json=nextRefreshAtMs,proto3" json:"next_refresh_at_ms,omitempty"` - LastRefreshAtMs int64 `protobuf:"varint,8,opt,name=last_refresh_at_ms,json=lastRefreshAtMs,proto3" json:"last_refresh_at_ms,omitempty"` - LastError string `protobuf:"bytes,9,opt,name=last_error,json=lastError,proto3" json:"last_error,omitempty"` - RecoveryAction ProviderCredentialRefreshRecoveryAction `protobuf:"varint,10,opt,name=recovery_action,json=recoveryAction,proto3,enum=openshell.v1.ProviderCredentialRefreshRecoveryAction" json:"recovery_action,omitempty"` - // Stable gateway-owned failure identifier, for example - // "oauth_invalid_grant". This is not provider-controlled prose and - // incorporates any recognized top-level OAuth error classification. - FailureCode string `protobuf:"bytes,11,opt,name=failure_code,json=failureCode,proto3" json:"failure_code,omitempty"` - // A bounded, recognized provider subtype that refines failure_code; clients - // do not need a separate provider_error field. Unknown provider-controlled - // values are not persisted or returned. - ProviderErrorSubtype string `protobuf:"bytes,12,opt,name=provider_error_subtype,json=providerErrorSubtype,proto3" json:"provider_error_subtype,omitempty"` - LastErrorAtMs int64 `protobuf:"varint,13,opt,name=last_error_at_ms,json=lastErrorAtMs,proto3" json:"last_error_at_ms,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +func (x *DelegatedIdentityCredential) GetAccessTokenExpiresAtMs() int64 { + if x != nil { + return x.AccessTokenExpiresAtMs + } + return 0 } -func (x *ProviderCredentialRefreshStatus) Reset() { - *x = ProviderCredentialRefreshStatus{} - mi := &file_openshell_proto_msgTypes[79] +func (x *DelegatedIdentityCredential) GetScopes() string { + if x != nil { + return x.Scopes + } + return "" +} + +func (x *DelegatedIdentityCredential) GetAudience() string { + if x != nil { + return x.Audience + } + return "" +} + +func (x *DelegatedIdentityCredential) GetLastRefreshAtMs() int64 { + if x != nil { + return x.LastRefreshAtMs + } + return 0 +} + +func (x *DelegatedIdentityCredential) GetRevokedAtMs() int64 { + if x != nil { + return x.RevokedAtMs + } + return 0 +} + +type DelegatedIdentityCredentialSummary struct { + state protoimpl.MessageState `protogen:"open.v1"` + Metadata *datamodelv1.ObjectMeta `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"` + Issuer string `protobuf:"bytes,2,opt,name=issuer,proto3" json:"issuer,omitempty"` + ClientId string `protobuf:"bytes,3,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"` + PrincipalSubject string `protobuf:"bytes,4,opt,name=principal_subject,json=principalSubject,proto3" json:"principal_subject,omitempty"` + RefreshTokenPresent bool `protobuf:"varint,5,opt,name=refresh_token_present,json=refreshTokenPresent,proto3" json:"refresh_token_present,omitempty"` + AccessTokenPresent bool `protobuf:"varint,6,opt,name=access_token_present,json=accessTokenPresent,proto3" json:"access_token_present,omitempty"` + AccessTokenExpiresAtMs int64 `protobuf:"varint,7,opt,name=access_token_expires_at_ms,json=accessTokenExpiresAtMs,proto3" json:"access_token_expires_at_ms,omitempty"` + Scopes string `protobuf:"bytes,8,opt,name=scopes,proto3" json:"scopes,omitempty"` + Audience string `protobuf:"bytes,9,opt,name=audience,proto3" json:"audience,omitempty"` + LastRefreshAtMs int64 `protobuf:"varint,10,opt,name=last_refresh_at_ms,json=lastRefreshAtMs,proto3" json:"last_refresh_at_ms,omitempty"` + RevokedAtMs int64 `protobuf:"varint,11,opt,name=revoked_at_ms,json=revokedAtMs,proto3" json:"revoked_at_ms,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DelegatedIdentityCredentialSummary) Reset() { + *x = DelegatedIdentityCredentialSummary{} + mi := &file_openshell_proto_msgTypes[93] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ProviderCredentialRefreshStatus) String() string { +func (x *DelegatedIdentityCredentialSummary) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ProviderCredentialRefreshStatus) ProtoMessage() {} +func (*DelegatedIdentityCredentialSummary) ProtoMessage() {} -func (x *ProviderCredentialRefreshStatus) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[79] +func (x *DelegatedIdentityCredentialSummary) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[93] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5990,126 +7161,162 @@ func (x *ProviderCredentialRefreshStatus) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ProviderCredentialRefreshStatus.ProtoReflect.Descriptor instead. -func (*ProviderCredentialRefreshStatus) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{79} +// Deprecated: Use DelegatedIdentityCredentialSummary.ProtoReflect.Descriptor instead. +func (*DelegatedIdentityCredentialSummary) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{93} } -func (x *ProviderCredentialRefreshStatus) GetProviderName() string { +func (x *DelegatedIdentityCredentialSummary) GetMetadata() *datamodelv1.ObjectMeta { if x != nil { - return x.ProviderName + return x.Metadata } - return "" + return nil } -func (x *ProviderCredentialRefreshStatus) GetProviderId() string { +func (x *DelegatedIdentityCredentialSummary) GetIssuer() string { if x != nil { - return x.ProviderId + return x.Issuer } return "" } -func (x *ProviderCredentialRefreshStatus) GetCredentialKey() string { +func (x *DelegatedIdentityCredentialSummary) GetClientId() string { if x != nil { - return x.CredentialKey + return x.ClientId } return "" } -func (x *ProviderCredentialRefreshStatus) GetStrategy() ProviderCredentialRefreshStrategy { +func (x *DelegatedIdentityCredentialSummary) GetPrincipalSubject() string { if x != nil { - return x.Strategy + return x.PrincipalSubject } - return ProviderCredentialRefreshStrategy_PROVIDER_CREDENTIAL_REFRESH_STRATEGY_UNSPECIFIED + return "" } -func (x *ProviderCredentialRefreshStatus) GetStatus() string { +func (x *DelegatedIdentityCredentialSummary) GetRefreshTokenPresent() bool { if x != nil { - return x.Status + return x.RefreshTokenPresent } - return "" + return false } -func (x *ProviderCredentialRefreshStatus) GetExpiresAtMs() int64 { +func (x *DelegatedIdentityCredentialSummary) GetAccessTokenPresent() bool { if x != nil { - return x.ExpiresAtMs + return x.AccessTokenPresent } - return 0 + return false } -func (x *ProviderCredentialRefreshStatus) GetNextRefreshAtMs() int64 { +func (x *DelegatedIdentityCredentialSummary) GetAccessTokenExpiresAtMs() int64 { if x != nil { - return x.NextRefreshAtMs + return x.AccessTokenExpiresAtMs } return 0 } -func (x *ProviderCredentialRefreshStatus) GetLastRefreshAtMs() int64 { +func (x *DelegatedIdentityCredentialSummary) GetScopes() string { if x != nil { - return x.LastRefreshAtMs + return x.Scopes } - return 0 + return "" } -func (x *ProviderCredentialRefreshStatus) GetLastError() string { +func (x *DelegatedIdentityCredentialSummary) GetAudience() string { if x != nil { - return x.LastError + return x.Audience } return "" } -func (x *ProviderCredentialRefreshStatus) GetRecoveryAction() ProviderCredentialRefreshRecoveryAction { +func (x *DelegatedIdentityCredentialSummary) GetLastRefreshAtMs() int64 { if x != nil { - return x.RecoveryAction + return x.LastRefreshAtMs } - return ProviderCredentialRefreshRecoveryAction_PROVIDER_CREDENTIAL_REFRESH_RECOVERY_ACTION_UNSPECIFIED + return 0 } -func (x *ProviderCredentialRefreshStatus) GetFailureCode() string { +func (x *DelegatedIdentityCredentialSummary) GetRevokedAtMs() int64 { if x != nil { - return x.FailureCode + return x.RevokedAtMs } - return "" + return 0 } -func (x *ProviderCredentialRefreshStatus) GetProviderErrorSubtype() string { +type ListDelegatedIdentityCredentialsRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Limit uint32 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"` + Offset uint32 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListDelegatedIdentityCredentialsRequest) Reset() { + *x = ListDelegatedIdentityCredentialsRequest{} + mi := &file_openshell_proto_msgTypes[94] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListDelegatedIdentityCredentialsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListDelegatedIdentityCredentialsRequest) ProtoMessage() {} + +func (x *ListDelegatedIdentityCredentialsRequest) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[94] if x != nil { - return x.ProviderErrorSubtype + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return "" + return mi.MessageOf(x) } -func (x *ProviderCredentialRefreshStatus) GetLastErrorAtMs() int64 { +// Deprecated: Use ListDelegatedIdentityCredentialsRequest.ProtoReflect.Descriptor instead. +func (*ListDelegatedIdentityCredentialsRequest) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{94} +} + +func (x *ListDelegatedIdentityCredentialsRequest) GetLimit() uint32 { if x != nil { - return x.LastErrorAtMs + return x.Limit } return 0 } -// Provider profile local discovery declaration. -type ProviderProfileDiscovery struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Credential names from ProviderProfile.credentials eligible for local discovery. - Credentials []string `protobuf:"bytes,1,rep,name=credentials,proto3" json:"credentials,omitempty"` +func (x *ListDelegatedIdentityCredentialsRequest) GetOffset() uint32 { + if x != nil { + return x.Offset + } + return 0 +} + +type ListDelegatedIdentityCredentialsResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Credentials []*DelegatedIdentityCredentialSummary `protobuf:"bytes,1,rep,name=credentials,proto3" json:"credentials,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ProviderProfileDiscovery) Reset() { - *x = ProviderProfileDiscovery{} - mi := &file_openshell_proto_msgTypes[80] +func (x *ListDelegatedIdentityCredentialsResponse) Reset() { + *x = ListDelegatedIdentityCredentialsResponse{} + mi := &file_openshell_proto_msgTypes[95] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ProviderProfileDiscovery) String() string { +func (x *ListDelegatedIdentityCredentialsResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ProviderProfileDiscovery) ProtoMessage() {} +func (*ListDelegatedIdentityCredentialsResponse) ProtoMessage() {} -func (x *ProviderProfileDiscovery) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[80] +func (x *ListDelegatedIdentityCredentialsResponse) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[95] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6120,85 +7327,40 @@ func (x *ProviderProfileDiscovery) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ProviderProfileDiscovery.ProtoReflect.Descriptor instead. -func (*ProviderProfileDiscovery) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{80} +// Deprecated: Use ListDelegatedIdentityCredentialsResponse.ProtoReflect.Descriptor instead. +func (*ListDelegatedIdentityCredentialsResponse) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{95} } -func (x *ProviderProfileDiscovery) GetCredentials() []string { +func (x *ListDelegatedIdentityCredentialsResponse) GetCredentials() []*DelegatedIdentityCredentialSummary { if x != nil { return x.Credentials } return nil } -type StoredProviderCredentialRefreshState struct { - state protoimpl.MessageState `protogen:"open.v1"` - Metadata *datamodelv1.ObjectMeta `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"` - ProviderId string `protobuf:"bytes,2,opt,name=provider_id,json=providerId,proto3" json:"provider_id,omitempty"` - ProviderName string `protobuf:"bytes,3,opt,name=provider_name,json=providerName,proto3" json:"provider_name,omitempty"` - CredentialKey string `protobuf:"bytes,4,opt,name=credential_key,json=credentialKey,proto3" json:"credential_key,omitempty"` - Strategy ProviderCredentialRefreshStrategy `protobuf:"varint,5,opt,name=strategy,proto3,enum=openshell.v1.ProviderCredentialRefreshStrategy" json:"strategy,omitempty"` - Material map[string]string `protobuf:"bytes,6,rep,name=material,proto3" json:"material,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - // Material names classified as secret. Newly configured values live in the - // active credential driver and are absent from material. Legacy inline values - // are not automatically migrated before OpenShell 0.1.0. - SecretMaterialKeys []string `protobuf:"bytes,7,rep,name=secret_material_keys,json=secretMaterialKeys,proto3" json:"secret_material_keys,omitempty"` - ExpiresAtMs int64 `protobuf:"varint,8,opt,name=expires_at_ms,json=expiresAtMs,proto3" json:"expires_at_ms,omitempty"` - // int64 max parks the refresh until an explicit rotation or reconfiguration. - NextRefreshAtMs int64 `protobuf:"varint,9,opt,name=next_refresh_at_ms,json=nextRefreshAtMs,proto3" json:"next_refresh_at_ms,omitempty"` - LastRefreshAtMs int64 `protobuf:"varint,10,opt,name=last_refresh_at_ms,json=lastRefreshAtMs,proto3" json:"last_refresh_at_ms,omitempty"` - Status string `protobuf:"bytes,11,opt,name=status,proto3" json:"status,omitempty"` - LastError string `protobuf:"bytes,12,opt,name=last_error,json=lastError,proto3" json:"last_error,omitempty"` - TokenUrl string `protobuf:"bytes,13,opt,name=token_url,json=tokenUrl,proto3" json:"token_url,omitempty"` - Scopes []string `protobuf:"bytes,14,rep,name=scopes,proto3" json:"scopes,omitempty"` - RefreshBeforeSeconds int64 `protobuf:"varint,15,opt,name=refresh_before_seconds,json=refreshBeforeSeconds,proto3" json:"refresh_before_seconds,omitempty"` - MaxLifetimeSeconds int64 `protobuf:"varint,16,opt,name=max_lifetime_seconds,json=maxLifetimeSeconds,proto3" json:"max_lifetime_seconds,omitempty"` - // Resolved mapping of strategy-defined output id -> concrete env key, pinned - // at configure time from the profile's additional_outputs. Read by minting, - // collision reservation, and env-key surfacing so later profile edits cannot - // silently redirect writes. - AdditionalOutputKeys map[string]string `protobuf:"bytes,17,rep,name=additional_output_keys,json=additionalOutputKeys,proto3" json:"additional_output_keys,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - // Opaque gateway-owned authorization epoch for the configured refresh - // grant. Explicit refresh configuration creates a new epoch; automatic and - // manual token rotation preserve it. It is never derived from or exposed - // with refresh material. - AuthorizationEpoch string `protobuf:"bytes,18,opt,name=authorization_epoch,json=authorizationEpoch,proto3" json:"authorization_epoch,omitempty"` - // Secret refresh material is stored through the gateway's active credential - // driver. The persisted refresh state keeps only opaque handles; resolved - // values exist in gateway memory for the duration of one mint operation. - SecretMaterialHandles map[string]*datamodelv1.CredentialHandle `protobuf:"bytes,19,rep,name=secret_material_handles,json=secretMaterialHandles,proto3" json:"secret_material_handles,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - // Handles replaced by reconfiguration or issuer-driven refresh-token - // rotation. This is a repeated entry rather than a material-keyed map so - // multiple superseded generations of the same material remain recoverable. - // Cleanup is retried by the refresh worker so a gateway crash or temporary - // credential-backend outage does not lose the deletion reference. - PendingSecretDeletions []*StoredRefreshMaterialDeletion `protobuf:"bytes,20,rep,name=pending_secret_deletions,json=pendingSecretDeletions,proto3" json:"pending_secret_deletions,omitempty"` - // Structured recovery details for the most recent refresh failure. These - // fields contain only gateway-owned codes and recognized bounded values. - RecoveryAction ProviderCredentialRefreshRecoveryAction `protobuf:"varint,21,opt,name=recovery_action,json=recoveryAction,proto3,enum=openshell.v1.ProviderCredentialRefreshRecoveryAction" json:"recovery_action,omitempty"` - FailureCode string `protobuf:"bytes,22,opt,name=failure_code,json=failureCode,proto3" json:"failure_code,omitempty"` - ProviderErrorSubtype string `protobuf:"bytes,23,opt,name=provider_error_subtype,json=providerErrorSubtype,proto3" json:"provider_error_subtype,omitempty"` - LastErrorAtMs int64 `protobuf:"varint,24,opt,name=last_error_at_ms,json=lastErrorAtMs,proto3" json:"last_error_at_ms,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type GetDelegatedIdentityCredentialStatusRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *StoredProviderCredentialRefreshState) Reset() { - *x = StoredProviderCredentialRefreshState{} - mi := &file_openshell_proto_msgTypes[81] +func (x *GetDelegatedIdentityCredentialStatusRequest) Reset() { + *x = GetDelegatedIdentityCredentialStatusRequest{} + mi := &file_openshell_proto_msgTypes[96] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *StoredProviderCredentialRefreshState) String() string { +func (x *GetDelegatedIdentityCredentialStatusRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*StoredProviderCredentialRefreshState) ProtoMessage() {} +func (*GetDelegatedIdentityCredentialStatusRequest) ProtoMessage() {} -func (x *StoredProviderCredentialRefreshState) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[81] +func (x *GetDelegatedIdentityCredentialStatusRequest) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[96] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6209,204 +7371,256 @@ func (x *StoredProviderCredentialRefreshState) ProtoReflect() protoreflect.Messa return mi.MessageOf(x) } -// Deprecated: Use StoredProviderCredentialRefreshState.ProtoReflect.Descriptor instead. -func (*StoredProviderCredentialRefreshState) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{81} +// Deprecated: Use GetDelegatedIdentityCredentialStatusRequest.ProtoReflect.Descriptor instead. +func (*GetDelegatedIdentityCredentialStatusRequest) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{96} } -func (x *StoredProviderCredentialRefreshState) GetMetadata() *datamodelv1.ObjectMeta { +func (x *GetDelegatedIdentityCredentialStatusRequest) GetId() string { if x != nil { - return x.Metadata + return x.Id } - return nil + return "" } -func (x *StoredProviderCredentialRefreshState) GetProviderId() string { - if x != nil { - return x.ProviderId - } - return "" +type GetDelegatedIdentityCredentialStatusResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Credential *DelegatedIdentityCredentialSummary `protobuf:"bytes,1,opt,name=credential,proto3" json:"credential,omitempty"` + NowMs int64 `protobuf:"varint,2,opt,name=now_ms,json=nowMs,proto3" json:"now_ms,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *StoredProviderCredentialRefreshState) GetProviderName() string { +func (x *GetDelegatedIdentityCredentialStatusResponse) Reset() { + *x = GetDelegatedIdentityCredentialStatusResponse{} + mi := &file_openshell_proto_msgTypes[97] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetDelegatedIdentityCredentialStatusResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetDelegatedIdentityCredentialStatusResponse) ProtoMessage() {} + +func (x *GetDelegatedIdentityCredentialStatusResponse) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[97] if x != nil { - return x.ProviderName + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return "" + return mi.MessageOf(x) } -func (x *StoredProviderCredentialRefreshState) GetCredentialKey() string { +// Deprecated: Use GetDelegatedIdentityCredentialStatusResponse.ProtoReflect.Descriptor instead. +func (*GetDelegatedIdentityCredentialStatusResponse) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{97} +} + +func (x *GetDelegatedIdentityCredentialStatusResponse) GetCredential() *DelegatedIdentityCredentialSummary { if x != nil { - return x.CredentialKey + return x.Credential } - return "" + return nil } -func (x *StoredProviderCredentialRefreshState) GetStrategy() ProviderCredentialRefreshStrategy { +func (x *GetDelegatedIdentityCredentialStatusResponse) GetNowMs() int64 { if x != nil { - return x.Strategy + return x.NowMs } - return ProviderCredentialRefreshStrategy_PROVIDER_CREDENTIAL_REFRESH_STRATEGY_UNSPECIFIED + return 0 +} + +type RevokeDelegatedIdentityCredentialRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + ExpectedResourceVersion uint64 `protobuf:"varint,2,opt,name=expected_resource_version,json=expectedResourceVersion,proto3" json:"expected_resource_version,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RevokeDelegatedIdentityCredentialRequest) Reset() { + *x = RevokeDelegatedIdentityCredentialRequest{} + mi := &file_openshell_proto_msgTypes[98] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } -func (x *StoredProviderCredentialRefreshState) GetMaterial() map[string]string { +func (x *RevokeDelegatedIdentityCredentialRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RevokeDelegatedIdentityCredentialRequest) ProtoMessage() {} + +func (x *RevokeDelegatedIdentityCredentialRequest) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[98] if x != nil { - return x.Material + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return nil + return mi.MessageOf(x) } -func (x *StoredProviderCredentialRefreshState) GetSecretMaterialKeys() []string { - if x != nil { - return x.SecretMaterialKeys - } - return nil +// Deprecated: Use RevokeDelegatedIdentityCredentialRequest.ProtoReflect.Descriptor instead. +func (*RevokeDelegatedIdentityCredentialRequest) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{98} } -func (x *StoredProviderCredentialRefreshState) GetExpiresAtMs() int64 { +func (x *RevokeDelegatedIdentityCredentialRequest) GetId() string { if x != nil { - return x.ExpiresAtMs + return x.Id } - return 0 + return "" } -func (x *StoredProviderCredentialRefreshState) GetNextRefreshAtMs() int64 { +func (x *RevokeDelegatedIdentityCredentialRequest) GetExpectedResourceVersion() uint64 { if x != nil { - return x.NextRefreshAtMs + return x.ExpectedResourceVersion } return 0 } -func (x *StoredProviderCredentialRefreshState) GetLastRefreshAtMs() int64 { - if x != nil { - return x.LastRefreshAtMs - } - return 0 +type RevokeDelegatedIdentityCredentialResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Revoked bool `protobuf:"varint,2,opt,name=revoked,proto3" json:"revoked,omitempty"` + RevokedAtMs int64 `protobuf:"varint,3,opt,name=revoked_at_ms,json=revokedAtMs,proto3" json:"revoked_at_ms,omitempty"` + ResourceVersion uint64 `protobuf:"varint,4,opt,name=resource_version,json=resourceVersion,proto3" json:"resource_version,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *StoredProviderCredentialRefreshState) GetStatus() string { - if x != nil { - return x.Status - } - return "" +func (x *RevokeDelegatedIdentityCredentialResponse) Reset() { + *x = RevokeDelegatedIdentityCredentialResponse{} + mi := &file_openshell_proto_msgTypes[99] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } -func (x *StoredProviderCredentialRefreshState) GetLastError() string { - if x != nil { - return x.LastError - } - return "" +func (x *RevokeDelegatedIdentityCredentialResponse) String() string { + return protoimpl.X.MessageStringOf(x) } -func (x *StoredProviderCredentialRefreshState) GetTokenUrl() string { +func (*RevokeDelegatedIdentityCredentialResponse) ProtoMessage() {} + +func (x *RevokeDelegatedIdentityCredentialResponse) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[99] if x != nil { - return x.TokenUrl + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return "" + return mi.MessageOf(x) } -func (x *StoredProviderCredentialRefreshState) GetScopes() []string { - if x != nil { - return x.Scopes - } - return nil +// Deprecated: Use RevokeDelegatedIdentityCredentialResponse.ProtoReflect.Descriptor instead. +func (*RevokeDelegatedIdentityCredentialResponse) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{99} } -func (x *StoredProviderCredentialRefreshState) GetRefreshBeforeSeconds() int64 { +func (x *RevokeDelegatedIdentityCredentialResponse) GetRevoked() bool { if x != nil { - return x.RefreshBeforeSeconds + return x.Revoked } - return 0 + return false } -func (x *StoredProviderCredentialRefreshState) GetMaxLifetimeSeconds() int64 { +func (x *RevokeDelegatedIdentityCredentialResponse) GetRevokedAtMs() int64 { if x != nil { - return x.MaxLifetimeSeconds + return x.RevokedAtMs } return 0 } -func (x *StoredProviderCredentialRefreshState) GetAdditionalOutputKeys() map[string]string { +func (x *RevokeDelegatedIdentityCredentialResponse) GetResourceVersion() uint64 { if x != nil { - return x.AdditionalOutputKeys + return x.ResourceVersion } - return nil + return 0 } -func (x *StoredProviderCredentialRefreshState) GetAuthorizationEpoch() string { - if x != nil { - return x.AuthorizationEpoch - } - return "" +type DeleteDelegatedIdentityCredentialRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + ExpectedResourceVersion uint64 `protobuf:"varint,2,opt,name=expected_resource_version,json=expectedResourceVersion,proto3" json:"expected_resource_version,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *StoredProviderCredentialRefreshState) GetSecretMaterialHandles() map[string]*datamodelv1.CredentialHandle { - if x != nil { - return x.SecretMaterialHandles - } - return nil +func (x *DeleteDelegatedIdentityCredentialRequest) Reset() { + *x = DeleteDelegatedIdentityCredentialRequest{} + mi := &file_openshell_proto_msgTypes[100] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } -func (x *StoredProviderCredentialRefreshState) GetPendingSecretDeletions() []*StoredRefreshMaterialDeletion { - if x != nil { - return x.PendingSecretDeletions - } - return nil +func (x *DeleteDelegatedIdentityCredentialRequest) String() string { + return protoimpl.X.MessageStringOf(x) } -func (x *StoredProviderCredentialRefreshState) GetRecoveryAction() ProviderCredentialRefreshRecoveryAction { +func (*DeleteDelegatedIdentityCredentialRequest) ProtoMessage() {} + +func (x *DeleteDelegatedIdentityCredentialRequest) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[100] if x != nil { - return x.RecoveryAction + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return ProviderCredentialRefreshRecoveryAction_PROVIDER_CREDENTIAL_REFRESH_RECOVERY_ACTION_UNSPECIFIED + return mi.MessageOf(x) } -func (x *StoredProviderCredentialRefreshState) GetFailureCode() string { - if x != nil { - return x.FailureCode - } - return "" +// Deprecated: Use DeleteDelegatedIdentityCredentialRequest.ProtoReflect.Descriptor instead. +func (*DeleteDelegatedIdentityCredentialRequest) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{100} } -func (x *StoredProviderCredentialRefreshState) GetProviderErrorSubtype() string { +func (x *DeleteDelegatedIdentityCredentialRequest) GetId() string { if x != nil { - return x.ProviderErrorSubtype + return x.Id } return "" } -func (x *StoredProviderCredentialRefreshState) GetLastErrorAtMs() int64 { +func (x *DeleteDelegatedIdentityCredentialRequest) GetExpectedResourceVersion() uint64 { if x != nil { - return x.LastErrorAtMs + return x.ExpectedResourceVersion } return 0 } -type StoredRefreshMaterialDeletion struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Original material name used to derive the credential driver's storage key. - MaterialKey string `protobuf:"bytes,1,opt,name=material_key,json=materialKey,proto3" json:"material_key,omitempty"` - // Opaque handle for the superseded secret object. - Handle *datamodelv1.CredentialHandle `protobuf:"bytes,2,opt,name=handle,proto3" json:"handle,omitempty"` +type DeleteDelegatedIdentityCredentialResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Deleted bool `protobuf:"varint,1,opt,name=deleted,proto3" json:"deleted,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *StoredRefreshMaterialDeletion) Reset() { - *x = StoredRefreshMaterialDeletion{} - mi := &file_openshell_proto_msgTypes[82] +func (x *DeleteDelegatedIdentityCredentialResponse) Reset() { + *x = DeleteDelegatedIdentityCredentialResponse{} + mi := &file_openshell_proto_msgTypes[101] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *StoredRefreshMaterialDeletion) String() string { +func (x *DeleteDelegatedIdentityCredentialResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*StoredRefreshMaterialDeletion) ProtoMessage() {} +func (*DeleteDelegatedIdentityCredentialResponse) ProtoMessage() {} -func (x *StoredRefreshMaterialDeletion) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[82] +func (x *DeleteDelegatedIdentityCredentialResponse) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[101] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6417,23 +7631,16 @@ func (x *StoredRefreshMaterialDeletion) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use StoredRefreshMaterialDeletion.ProtoReflect.Descriptor instead. -func (*StoredRefreshMaterialDeletion) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{82} -} - -func (x *StoredRefreshMaterialDeletion) GetMaterialKey() string { - if x != nil { - return x.MaterialKey - } - return "" +// Deprecated: Use DeleteDelegatedIdentityCredentialResponse.ProtoReflect.Descriptor instead. +func (*DeleteDelegatedIdentityCredentialResponse) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{101} } -func (x *StoredRefreshMaterialDeletion) GetHandle() *datamodelv1.CredentialHandle { +func (x *DeleteDelegatedIdentityCredentialResponse) GetDeleted() bool { if x != nil { - return x.Handle + return x.Deleted } - return nil + return false } type GetProviderRefreshStatusRequest struct { @@ -6448,7 +7655,7 @@ type GetProviderRefreshStatusRequest struct { func (x *GetProviderRefreshStatusRequest) Reset() { *x = GetProviderRefreshStatusRequest{} - mi := &file_openshell_proto_msgTypes[83] + mi := &file_openshell_proto_msgTypes[102] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6460,7 +7667,7 @@ func (x *GetProviderRefreshStatusRequest) String() string { func (*GetProviderRefreshStatusRequest) ProtoMessage() {} func (x *GetProviderRefreshStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[83] + mi := &file_openshell_proto_msgTypes[102] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6473,7 +7680,7 @@ func (x *GetProviderRefreshStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderRefreshStatusRequest.ProtoReflect.Descriptor instead. func (*GetProviderRefreshStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{83} + return file_openshell_proto_rawDescGZIP(), []int{102} } func (x *GetProviderRefreshStatusRequest) GetProvider() string { @@ -6506,7 +7713,7 @@ type GetProviderRefreshStatusResponse struct { func (x *GetProviderRefreshStatusResponse) Reset() { *x = GetProviderRefreshStatusResponse{} - mi := &file_openshell_proto_msgTypes[84] + mi := &file_openshell_proto_msgTypes[103] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6518,7 +7725,7 @@ func (x *GetProviderRefreshStatusResponse) String() string { func (*GetProviderRefreshStatusResponse) ProtoMessage() {} func (x *GetProviderRefreshStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[84] + mi := &file_openshell_proto_msgTypes[103] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6531,7 +7738,7 @@ func (x *GetProviderRefreshStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderRefreshStatusResponse.ProtoReflect.Descriptor instead. func (*GetProviderRefreshStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{84} + return file_openshell_proto_rawDescGZIP(), []int{103} } func (x *GetProviderRefreshStatusResponse) GetCredentials() []*ProviderCredentialRefreshStatus { @@ -6560,7 +7767,7 @@ type ConfigureProviderRefreshRequest struct { func (x *ConfigureProviderRefreshRequest) Reset() { *x = ConfigureProviderRefreshRequest{} - mi := &file_openshell_proto_msgTypes[85] + mi := &file_openshell_proto_msgTypes[104] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6572,7 +7779,7 @@ func (x *ConfigureProviderRefreshRequest) String() string { func (*ConfigureProviderRefreshRequest) ProtoMessage() {} func (x *ConfigureProviderRefreshRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[85] + mi := &file_openshell_proto_msgTypes[104] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6585,7 +7792,7 @@ func (x *ConfigureProviderRefreshRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ConfigureProviderRefreshRequest.ProtoReflect.Descriptor instead. func (*ConfigureProviderRefreshRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{85} + return file_openshell_proto_rawDescGZIP(), []int{104} } func (x *ConfigureProviderRefreshRequest) GetProvider() string { @@ -6646,7 +7853,7 @@ type ConfigureProviderRefreshResponse struct { func (x *ConfigureProviderRefreshResponse) Reset() { *x = ConfigureProviderRefreshResponse{} - mi := &file_openshell_proto_msgTypes[86] + mi := &file_openshell_proto_msgTypes[105] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6658,7 +7865,7 @@ func (x *ConfigureProviderRefreshResponse) String() string { func (*ConfigureProviderRefreshResponse) ProtoMessage() {} func (x *ConfigureProviderRefreshResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[86] + mi := &file_openshell_proto_msgTypes[105] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6671,7 +7878,7 @@ func (x *ConfigureProviderRefreshResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ConfigureProviderRefreshResponse.ProtoReflect.Descriptor instead. func (*ConfigureProviderRefreshResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{86} + return file_openshell_proto_rawDescGZIP(), []int{105} } func (x *ConfigureProviderRefreshResponse) GetStatus() *ProviderCredentialRefreshStatus { @@ -6693,7 +7900,7 @@ type RotateProviderCredentialRequest struct { func (x *RotateProviderCredentialRequest) Reset() { *x = RotateProviderCredentialRequest{} - mi := &file_openshell_proto_msgTypes[87] + mi := &file_openshell_proto_msgTypes[106] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6705,7 +7912,7 @@ func (x *RotateProviderCredentialRequest) String() string { func (*RotateProviderCredentialRequest) ProtoMessage() {} func (x *RotateProviderCredentialRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[87] + mi := &file_openshell_proto_msgTypes[106] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6718,7 +7925,7 @@ func (x *RotateProviderCredentialRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RotateProviderCredentialRequest.ProtoReflect.Descriptor instead. func (*RotateProviderCredentialRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{87} + return file_openshell_proto_rawDescGZIP(), []int{106} } func (x *RotateProviderCredentialRequest) GetProvider() string { @@ -6751,7 +7958,7 @@ type RotateProviderCredentialResponse struct { func (x *RotateProviderCredentialResponse) Reset() { *x = RotateProviderCredentialResponse{} - mi := &file_openshell_proto_msgTypes[88] + mi := &file_openshell_proto_msgTypes[107] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6763,7 +7970,7 @@ func (x *RotateProviderCredentialResponse) String() string { func (*RotateProviderCredentialResponse) ProtoMessage() {} func (x *RotateProviderCredentialResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[88] + mi := &file_openshell_proto_msgTypes[107] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6776,7 +7983,7 @@ func (x *RotateProviderCredentialResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RotateProviderCredentialResponse.ProtoReflect.Descriptor instead. func (*RotateProviderCredentialResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{88} + return file_openshell_proto_rawDescGZIP(), []int{107} } func (x *RotateProviderCredentialResponse) GetStatus() *ProviderCredentialRefreshStatus { @@ -6798,7 +8005,7 @@ type DeleteProviderRefreshRequest struct { func (x *DeleteProviderRefreshRequest) Reset() { *x = DeleteProviderRefreshRequest{} - mi := &file_openshell_proto_msgTypes[89] + mi := &file_openshell_proto_msgTypes[108] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6810,7 +8017,7 @@ func (x *DeleteProviderRefreshRequest) String() string { func (*DeleteProviderRefreshRequest) ProtoMessage() {} func (x *DeleteProviderRefreshRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[89] + mi := &file_openshell_proto_msgTypes[108] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6823,7 +8030,7 @@ func (x *DeleteProviderRefreshRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderRefreshRequest.ProtoReflect.Descriptor instead. func (*DeleteProviderRefreshRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{89} + return file_openshell_proto_rawDescGZIP(), []int{108} } func (x *DeleteProviderRefreshRequest) GetProvider() string { @@ -6856,7 +8063,7 @@ type DeleteProviderRefreshResponse struct { func (x *DeleteProviderRefreshResponse) Reset() { *x = DeleteProviderRefreshResponse{} - mi := &file_openshell_proto_msgTypes[90] + mi := &file_openshell_proto_msgTypes[109] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6868,7 +8075,7 @@ func (x *DeleteProviderRefreshResponse) String() string { func (*DeleteProviderRefreshResponse) ProtoMessage() {} func (x *DeleteProviderRefreshResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[90] + mi := &file_openshell_proto_msgTypes[109] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6881,7 +8088,7 @@ func (x *DeleteProviderRefreshResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderRefreshResponse.ProtoReflect.Descriptor instead. func (*DeleteProviderRefreshResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{90} + return file_openshell_proto_rawDescGZIP(), []int{109} } func (x *DeleteProviderRefreshResponse) GetDeleted() bool { @@ -6921,7 +8128,7 @@ type ProviderProfile struct { func (x *ProviderProfile) Reset() { *x = ProviderProfile{} - mi := &file_openshell_proto_msgTypes[91] + mi := &file_openshell_proto_msgTypes[110] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6933,7 +8140,7 @@ func (x *ProviderProfile) String() string { func (*ProviderProfile) ProtoMessage() {} func (x *ProviderProfile) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[91] + mi := &file_openshell_proto_msgTypes[110] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6946,7 +8153,7 @@ func (x *ProviderProfile) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfile.ProtoReflect.Descriptor instead. func (*ProviderProfile) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{91} + return file_openshell_proto_rawDescGZIP(), []int{110} } func (x *ProviderProfile) GetId() string { @@ -7051,7 +8258,7 @@ type StoredProviderProfile struct { func (x *StoredProviderProfile) Reset() { *x = StoredProviderProfile{} - mi := &file_openshell_proto_msgTypes[92] + mi := &file_openshell_proto_msgTypes[111] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7063,7 +8270,7 @@ func (x *StoredProviderProfile) String() string { func (*StoredProviderProfile) ProtoMessage() {} func (x *StoredProviderProfile) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[92] + mi := &file_openshell_proto_msgTypes[111] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7076,7 +8283,7 @@ func (x *StoredProviderProfile) ProtoReflect() protoreflect.Message { // Deprecated: Use StoredProviderProfile.ProtoReflect.Descriptor instead. func (*StoredProviderProfile) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{92} + return file_openshell_proto_rawDescGZIP(), []int{111} } func (x *StoredProviderProfile) GetMetadata() *datamodelv1.ObjectMeta { @@ -7103,7 +8310,7 @@ type ProviderProfileResponse struct { func (x *ProviderProfileResponse) Reset() { *x = ProviderProfileResponse{} - mi := &file_openshell_proto_msgTypes[93] + mi := &file_openshell_proto_msgTypes[112] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7115,7 +8322,7 @@ func (x *ProviderProfileResponse) String() string { func (*ProviderProfileResponse) ProtoMessage() {} func (x *ProviderProfileResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[93] + mi := &file_openshell_proto_msgTypes[112] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7128,7 +8335,7 @@ func (x *ProviderProfileResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileResponse.ProtoReflect.Descriptor instead. func (*ProviderProfileResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{93} + return file_openshell_proto_rawDescGZIP(), []int{112} } func (x *ProviderProfileResponse) GetProfile() *ProviderProfile { @@ -7148,7 +8355,7 @@ type ListProviderProfilesResponse struct { func (x *ListProviderProfilesResponse) Reset() { *x = ListProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[94] + mi := &file_openshell_proto_msgTypes[113] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7160,7 +8367,7 @@ func (x *ListProviderProfilesResponse) String() string { func (*ListProviderProfilesResponse) ProtoMessage() {} func (x *ListProviderProfilesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[94] + mi := &file_openshell_proto_msgTypes[113] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7173,7 +8380,7 @@ func (x *ListProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*ListProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{94} + return file_openshell_proto_rawDescGZIP(), []int{113} } func (x *ListProviderProfilesResponse) GetProfiles() []*ProviderProfile { @@ -7196,7 +8403,7 @@ type ImportProviderProfilesRequest struct { func (x *ImportProviderProfilesRequest) Reset() { *x = ImportProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[95] + mi := &file_openshell_proto_msgTypes[114] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7208,7 +8415,7 @@ func (x *ImportProviderProfilesRequest) String() string { func (*ImportProviderProfilesRequest) ProtoMessage() {} func (x *ImportProviderProfilesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[95] + mi := &file_openshell_proto_msgTypes[114] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7221,7 +8428,7 @@ func (x *ImportProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ImportProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*ImportProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{95} + return file_openshell_proto_rawDescGZIP(), []int{114} } func (x *ImportProviderProfilesRequest) GetProfiles() []*ProviderProfileImportItem { @@ -7250,7 +8457,7 @@ type ImportProviderProfilesResponse struct { func (x *ImportProviderProfilesResponse) Reset() { *x = ImportProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[96] + mi := &file_openshell_proto_msgTypes[115] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7262,7 +8469,7 @@ func (x *ImportProviderProfilesResponse) String() string { func (*ImportProviderProfilesResponse) ProtoMessage() {} func (x *ImportProviderProfilesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[96] + mi := &file_openshell_proto_msgTypes[115] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7275,7 +8482,7 @@ func (x *ImportProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ImportProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*ImportProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{96} + return file_openshell_proto_rawDescGZIP(), []int{115} } func (x *ImportProviderProfilesResponse) GetDiagnostics() []*ProviderProfileDiagnostic { @@ -7319,7 +8526,7 @@ type UpdateProviderProfilesRequest struct { func (x *UpdateProviderProfilesRequest) Reset() { *x = UpdateProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[97] + mi := &file_openshell_proto_msgTypes[116] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7331,7 +8538,7 @@ func (x *UpdateProviderProfilesRequest) String() string { func (*UpdateProviderProfilesRequest) ProtoMessage() {} func (x *UpdateProviderProfilesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[97] + mi := &file_openshell_proto_msgTypes[116] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7344,7 +8551,7 @@ func (x *UpdateProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*UpdateProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{97} + return file_openshell_proto_rawDescGZIP(), []int{116} } func (x *UpdateProviderProfilesRequest) GetProfile() *ProviderProfileImportItem { @@ -7387,7 +8594,7 @@ type UpdateProviderProfilesResponse struct { func (x *UpdateProviderProfilesResponse) Reset() { *x = UpdateProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[98] + mi := &file_openshell_proto_msgTypes[117] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7399,7 +8606,7 @@ func (x *UpdateProviderProfilesResponse) String() string { func (*UpdateProviderProfilesResponse) ProtoMessage() {} func (x *UpdateProviderProfilesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[98] + mi := &file_openshell_proto_msgTypes[117] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7412,7 +8619,7 @@ func (x *UpdateProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*UpdateProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{98} + return file_openshell_proto_rawDescGZIP(), []int{117} } func (x *UpdateProviderProfilesResponse) GetDiagnostics() []*ProviderProfileDiagnostic { @@ -7449,7 +8656,7 @@ type LintProviderProfilesRequest struct { func (x *LintProviderProfilesRequest) Reset() { *x = LintProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[99] + mi := &file_openshell_proto_msgTypes[118] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7461,7 +8668,7 @@ func (x *LintProviderProfilesRequest) String() string { func (*LintProviderProfilesRequest) ProtoMessage() {} func (x *LintProviderProfilesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[99] + mi := &file_openshell_proto_msgTypes[118] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7474,7 +8681,7 @@ func (x *LintProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use LintProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*LintProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{99} + return file_openshell_proto_rawDescGZIP(), []int{118} } func (x *LintProviderProfilesRequest) GetProfiles() []*ProviderProfileImportItem { @@ -7502,7 +8709,7 @@ type LintProviderProfilesResponse struct { func (x *LintProviderProfilesResponse) Reset() { *x = LintProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[100] + mi := &file_openshell_proto_msgTypes[119] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7514,7 +8721,7 @@ func (x *LintProviderProfilesResponse) String() string { func (*LintProviderProfilesResponse) ProtoMessage() {} func (x *LintProviderProfilesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[100] + mi := &file_openshell_proto_msgTypes[119] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7527,7 +8734,7 @@ func (x *LintProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use LintProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*LintProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{100} + return file_openshell_proto_rawDescGZIP(), []int{119} } func (x *LintProviderProfilesResponse) GetDiagnostics() []*ProviderProfileDiagnostic { @@ -7554,7 +8761,7 @@ type DeleteProviderResponse struct { func (x *DeleteProviderResponse) Reset() { *x = DeleteProviderResponse{} - mi := &file_openshell_proto_msgTypes[101] + mi := &file_openshell_proto_msgTypes[120] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7566,7 +8773,7 @@ func (x *DeleteProviderResponse) String() string { func (*DeleteProviderResponse) ProtoMessage() {} func (x *DeleteProviderResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[101] + mi := &file_openshell_proto_msgTypes[120] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7579,7 +8786,7 @@ func (x *DeleteProviderResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderResponse.ProtoReflect.Descriptor instead. func (*DeleteProviderResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{101} + return file_openshell_proto_rawDescGZIP(), []int{120} } func (x *DeleteProviderResponse) GetDeleted() bool { @@ -7602,7 +8809,7 @@ type DeleteProviderProfileRequest struct { func (x *DeleteProviderProfileRequest) Reset() { *x = DeleteProviderProfileRequest{} - mi := &file_openshell_proto_msgTypes[102] + mi := &file_openshell_proto_msgTypes[121] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7614,7 +8821,7 @@ func (x *DeleteProviderProfileRequest) String() string { func (*DeleteProviderProfileRequest) ProtoMessage() {} func (x *DeleteProviderProfileRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[102] + mi := &file_openshell_proto_msgTypes[121] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7627,7 +8834,7 @@ func (x *DeleteProviderProfileRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderProfileRequest.ProtoReflect.Descriptor instead. func (*DeleteProviderProfileRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{102} + return file_openshell_proto_rawDescGZIP(), []int{121} } func (x *DeleteProviderProfileRequest) GetId() string { @@ -7654,7 +8861,7 @@ type DeleteProviderProfileResponse struct { func (x *DeleteProviderProfileResponse) Reset() { *x = DeleteProviderProfileResponse{} - mi := &file_openshell_proto_msgTypes[103] + mi := &file_openshell_proto_msgTypes[122] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7666,7 +8873,7 @@ func (x *DeleteProviderProfileResponse) String() string { func (*DeleteProviderProfileResponse) ProtoMessage() {} func (x *DeleteProviderProfileResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[103] + mi := &file_openshell_proto_msgTypes[122] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7679,7 +8886,7 @@ func (x *DeleteProviderProfileResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderProfileResponse.ProtoReflect.Descriptor instead. func (*DeleteProviderProfileResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{103} + return file_openshell_proto_rawDescGZIP(), []int{122} } func (x *DeleteProviderProfileResponse) GetDeleted() bool { @@ -7704,7 +8911,7 @@ type GetSandboxProviderEnvironmentRequest struct { func (x *GetSandboxProviderEnvironmentRequest) Reset() { *x = GetSandboxProviderEnvironmentRequest{} - mi := &file_openshell_proto_msgTypes[104] + mi := &file_openshell_proto_msgTypes[123] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7716,7 +8923,7 @@ func (x *GetSandboxProviderEnvironmentRequest) String() string { func (*GetSandboxProviderEnvironmentRequest) ProtoMessage() {} func (x *GetSandboxProviderEnvironmentRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[104] + mi := &file_openshell_proto_msgTypes[123] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7729,7 +8936,7 @@ func (x *GetSandboxProviderEnvironmentRequest) ProtoReflect() protoreflect.Messa // Deprecated: Use GetSandboxProviderEnvironmentRequest.ProtoReflect.Descriptor instead. func (*GetSandboxProviderEnvironmentRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{104} + return file_openshell_proto_rawDescGZIP(), []int{123} } func (x *GetSandboxProviderEnvironmentRequest) GetSandboxId() string { @@ -7758,7 +8965,7 @@ type StaticCredentialEndpointBinding struct { func (x *StaticCredentialEndpointBinding) Reset() { *x = StaticCredentialEndpointBinding{} - mi := &file_openshell_proto_msgTypes[105] + mi := &file_openshell_proto_msgTypes[124] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7770,7 +8977,7 @@ func (x *StaticCredentialEndpointBinding) String() string { func (*StaticCredentialEndpointBinding) ProtoMessage() {} func (x *StaticCredentialEndpointBinding) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[105] + mi := &file_openshell_proto_msgTypes[124] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7783,7 +8990,7 @@ func (x *StaticCredentialEndpointBinding) ProtoReflect() protoreflect.Message { // Deprecated: Use StaticCredentialEndpointBinding.ProtoReflect.Descriptor instead. func (*StaticCredentialEndpointBinding) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{105} + return file_openshell_proto_rawDescGZIP(), []int{124} } func (x *StaticCredentialEndpointBinding) GetHost() string { @@ -7827,7 +9034,7 @@ type StaticCredentialBinding struct { func (x *StaticCredentialBinding) Reset() { *x = StaticCredentialBinding{} - mi := &file_openshell_proto_msgTypes[106] + mi := &file_openshell_proto_msgTypes[125] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7839,7 +9046,7 @@ func (x *StaticCredentialBinding) String() string { func (*StaticCredentialBinding) ProtoMessage() {} func (x *StaticCredentialBinding) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[106] + mi := &file_openshell_proto_msgTypes[125] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7852,7 +9059,7 @@ func (x *StaticCredentialBinding) ProtoReflect() protoreflect.Message { // Deprecated: Use StaticCredentialBinding.ProtoReflect.Descriptor instead. func (*StaticCredentialBinding) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{106} + return file_openshell_proto_rawDescGZIP(), []int{125} } func (x *StaticCredentialBinding) GetEndpoints() []*StaticCredentialEndpointBinding { @@ -7903,7 +9110,7 @@ type GetSandboxProviderEnvironmentResponse struct { func (x *GetSandboxProviderEnvironmentResponse) Reset() { *x = GetSandboxProviderEnvironmentResponse{} - mi := &file_openshell_proto_msgTypes[107] + mi := &file_openshell_proto_msgTypes[126] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7915,7 +9122,7 @@ func (x *GetSandboxProviderEnvironmentResponse) String() string { func (*GetSandboxProviderEnvironmentResponse) ProtoMessage() {} func (x *GetSandboxProviderEnvironmentResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[107] + mi := &file_openshell_proto_msgTypes[126] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7928,7 +9135,7 @@ func (x *GetSandboxProviderEnvironmentResponse) ProtoReflect() protoreflect.Mess // Deprecated: Use GetSandboxProviderEnvironmentResponse.ProtoReflect.Descriptor instead. func (*GetSandboxProviderEnvironmentResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{107} + return file_openshell_proto_rawDescGZIP(), []int{126} } func (x *GetSandboxProviderEnvironmentResponse) GetEnvironment() map[string]string { @@ -7990,7 +9197,7 @@ type ExchangeProviderSubjectTokenRequest struct { func (x *ExchangeProviderSubjectTokenRequest) Reset() { *x = ExchangeProviderSubjectTokenRequest{} - mi := &file_openshell_proto_msgTypes[108] + mi := &file_openshell_proto_msgTypes[127] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8002,7 +9209,7 @@ func (x *ExchangeProviderSubjectTokenRequest) String() string { func (*ExchangeProviderSubjectTokenRequest) ProtoMessage() {} func (x *ExchangeProviderSubjectTokenRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[108] + mi := &file_openshell_proto_msgTypes[127] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8015,7 +9222,7 @@ func (x *ExchangeProviderSubjectTokenRequest) ProtoReflect() protoreflect.Messag // Deprecated: Use ExchangeProviderSubjectTokenRequest.ProtoReflect.Descriptor instead. func (*ExchangeProviderSubjectTokenRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{108} + return file_openshell_proto_rawDescGZIP(), []int{127} } func (x *ExchangeProviderSubjectTokenRequest) GetSandboxId() string { @@ -8057,7 +9264,7 @@ type ExchangeProviderSubjectTokenResponse struct { func (x *ExchangeProviderSubjectTokenResponse) Reset() { *x = ExchangeProviderSubjectTokenResponse{} - mi := &file_openshell_proto_msgTypes[109] + mi := &file_openshell_proto_msgTypes[128] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8069,7 +9276,7 @@ func (x *ExchangeProviderSubjectTokenResponse) String() string { func (*ExchangeProviderSubjectTokenResponse) ProtoMessage() {} func (x *ExchangeProviderSubjectTokenResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[109] + mi := &file_openshell_proto_msgTypes[128] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8082,7 +9289,7 @@ func (x *ExchangeProviderSubjectTokenResponse) ProtoReflect() protoreflect.Messa // Deprecated: Use ExchangeProviderSubjectTokenResponse.ProtoReflect.Descriptor instead. func (*ExchangeProviderSubjectTokenResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{109} + return file_openshell_proto_rawDescGZIP(), []int{128} } func (x *ExchangeProviderSubjectTokenResponse) GetAccessToken() string { @@ -8153,7 +9360,7 @@ type UpdateConfigRequest struct { func (x *UpdateConfigRequest) Reset() { *x = UpdateConfigRequest{} - mi := &file_openshell_proto_msgTypes[110] + mi := &file_openshell_proto_msgTypes[129] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8165,7 +9372,7 @@ func (x *UpdateConfigRequest) String() string { func (*UpdateConfigRequest) ProtoMessage() {} func (x *UpdateConfigRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[110] + mi := &file_openshell_proto_msgTypes[129] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8178,7 +9385,7 @@ func (x *UpdateConfigRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateConfigRequest.ProtoReflect.Descriptor instead. func (*UpdateConfigRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{110} + return file_openshell_proto_rawDescGZIP(), []int{129} } func (x *UpdateConfigRequest) GetName() string { @@ -8268,7 +9475,7 @@ type PolicyMergeOperation struct { func (x *PolicyMergeOperation) Reset() { *x = PolicyMergeOperation{} - mi := &file_openshell_proto_msgTypes[111] + mi := &file_openshell_proto_msgTypes[130] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8280,7 +9487,7 @@ func (x *PolicyMergeOperation) String() string { func (*PolicyMergeOperation) ProtoMessage() {} func (x *PolicyMergeOperation) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[111] + mi := &file_openshell_proto_msgTypes[130] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8293,7 +9500,7 @@ func (x *PolicyMergeOperation) ProtoReflect() protoreflect.Message { // Deprecated: Use PolicyMergeOperation.ProtoReflect.Descriptor instead. func (*PolicyMergeOperation) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{111} + return file_openshell_proto_rawDescGZIP(), []int{130} } func (x *PolicyMergeOperation) GetOperation() isPolicyMergeOperation_Operation { @@ -8407,7 +9614,7 @@ type AddNetworkRule struct { func (x *AddNetworkRule) Reset() { *x = AddNetworkRule{} - mi := &file_openshell_proto_msgTypes[112] + mi := &file_openshell_proto_msgTypes[131] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8419,7 +9626,7 @@ func (x *AddNetworkRule) String() string { func (*AddNetworkRule) ProtoMessage() {} func (x *AddNetworkRule) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[112] + mi := &file_openshell_proto_msgTypes[131] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8432,7 +9639,7 @@ func (x *AddNetworkRule) ProtoReflect() protoreflect.Message { // Deprecated: Use AddNetworkRule.ProtoReflect.Descriptor instead. func (*AddNetworkRule) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{112} + return file_openshell_proto_rawDescGZIP(), []int{131} } func (x *AddNetworkRule) GetRuleName() string { @@ -8460,7 +9667,7 @@ type RemoveNetworkEndpoint struct { func (x *RemoveNetworkEndpoint) Reset() { *x = RemoveNetworkEndpoint{} - mi := &file_openshell_proto_msgTypes[113] + mi := &file_openshell_proto_msgTypes[132] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8472,7 +9679,7 @@ func (x *RemoveNetworkEndpoint) String() string { func (*RemoveNetworkEndpoint) ProtoMessage() {} func (x *RemoveNetworkEndpoint) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[113] + mi := &file_openshell_proto_msgTypes[132] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8485,7 +9692,7 @@ func (x *RemoveNetworkEndpoint) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveNetworkEndpoint.ProtoReflect.Descriptor instead. func (*RemoveNetworkEndpoint) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{113} + return file_openshell_proto_rawDescGZIP(), []int{132} } func (x *RemoveNetworkEndpoint) GetRuleName() string { @@ -8518,7 +9725,7 @@ type RemoveNetworkRule struct { func (x *RemoveNetworkRule) Reset() { *x = RemoveNetworkRule{} - mi := &file_openshell_proto_msgTypes[114] + mi := &file_openshell_proto_msgTypes[133] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8530,7 +9737,7 @@ func (x *RemoveNetworkRule) String() string { func (*RemoveNetworkRule) ProtoMessage() {} func (x *RemoveNetworkRule) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[114] + mi := &file_openshell_proto_msgTypes[133] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8543,7 +9750,7 @@ func (x *RemoveNetworkRule) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveNetworkRule.ProtoReflect.Descriptor instead. func (*RemoveNetworkRule) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{114} + return file_openshell_proto_rawDescGZIP(), []int{133} } func (x *RemoveNetworkRule) GetRuleName() string { @@ -8564,7 +9771,7 @@ type AddDenyRules struct { func (x *AddDenyRules) Reset() { *x = AddDenyRules{} - mi := &file_openshell_proto_msgTypes[115] + mi := &file_openshell_proto_msgTypes[134] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8576,7 +9783,7 @@ func (x *AddDenyRules) String() string { func (*AddDenyRules) ProtoMessage() {} func (x *AddDenyRules) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[115] + mi := &file_openshell_proto_msgTypes[134] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8589,7 +9796,7 @@ func (x *AddDenyRules) ProtoReflect() protoreflect.Message { // Deprecated: Use AddDenyRules.ProtoReflect.Descriptor instead. func (*AddDenyRules) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{115} + return file_openshell_proto_rawDescGZIP(), []int{134} } func (x *AddDenyRules) GetHost() string { @@ -8624,7 +9831,7 @@ type AddAllowRules struct { func (x *AddAllowRules) Reset() { *x = AddAllowRules{} - mi := &file_openshell_proto_msgTypes[116] + mi := &file_openshell_proto_msgTypes[135] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8636,7 +9843,7 @@ func (x *AddAllowRules) String() string { func (*AddAllowRules) ProtoMessage() {} func (x *AddAllowRules) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[116] + mi := &file_openshell_proto_msgTypes[135] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8649,7 +9856,7 @@ func (x *AddAllowRules) ProtoReflect() protoreflect.Message { // Deprecated: Use AddAllowRules.ProtoReflect.Descriptor instead. func (*AddAllowRules) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{116} + return file_openshell_proto_rawDescGZIP(), []int{135} } func (x *AddAllowRules) GetHost() string { @@ -8683,7 +9890,7 @@ type RemoveNetworkBinary struct { func (x *RemoveNetworkBinary) Reset() { *x = RemoveNetworkBinary{} - mi := &file_openshell_proto_msgTypes[117] + mi := &file_openshell_proto_msgTypes[136] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8695,7 +9902,7 @@ func (x *RemoveNetworkBinary) String() string { func (*RemoveNetworkBinary) ProtoMessage() {} func (x *RemoveNetworkBinary) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[117] + mi := &file_openshell_proto_msgTypes[136] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8708,7 +9915,7 @@ func (x *RemoveNetworkBinary) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveNetworkBinary.ProtoReflect.Descriptor instead. func (*RemoveNetworkBinary) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{117} + return file_openshell_proto_rawDescGZIP(), []int{136} } func (x *RemoveNetworkBinary) GetRuleName() string { @@ -8744,7 +9951,7 @@ type UpdateConfigResponse struct { func (x *UpdateConfigResponse) Reset() { *x = UpdateConfigResponse{} - mi := &file_openshell_proto_msgTypes[118] + mi := &file_openshell_proto_msgTypes[137] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8756,7 +9963,7 @@ func (x *UpdateConfigResponse) String() string { func (*UpdateConfigResponse) ProtoMessage() {} func (x *UpdateConfigResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[118] + mi := &file_openshell_proto_msgTypes[137] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8769,7 +9976,7 @@ func (x *UpdateConfigResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateConfigResponse.ProtoReflect.Descriptor instead. func (*UpdateConfigResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{118} + return file_openshell_proto_rawDescGZIP(), []int{137} } func (x *UpdateConfigResponse) GetVersion() uint32 { @@ -8824,7 +10031,7 @@ type GetSandboxPolicyStatusRequest struct { func (x *GetSandboxPolicyStatusRequest) Reset() { *x = GetSandboxPolicyStatusRequest{} - mi := &file_openshell_proto_msgTypes[119] + mi := &file_openshell_proto_msgTypes[138] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8836,7 +10043,7 @@ func (x *GetSandboxPolicyStatusRequest) String() string { func (*GetSandboxPolicyStatusRequest) ProtoMessage() {} func (x *GetSandboxPolicyStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[119] + mi := &file_openshell_proto_msgTypes[138] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8849,7 +10056,7 @@ func (x *GetSandboxPolicyStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxPolicyStatusRequest.ProtoReflect.Descriptor instead. func (*GetSandboxPolicyStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{119} + return file_openshell_proto_rawDescGZIP(), []int{138} } func (x *GetSandboxPolicyStatusRequest) GetName() string { @@ -8893,7 +10100,7 @@ type GetSandboxPolicyStatusResponse struct { func (x *GetSandboxPolicyStatusResponse) Reset() { *x = GetSandboxPolicyStatusResponse{} - mi := &file_openshell_proto_msgTypes[120] + mi := &file_openshell_proto_msgTypes[139] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8905,7 +10112,7 @@ func (x *GetSandboxPolicyStatusResponse) String() string { func (*GetSandboxPolicyStatusResponse) ProtoMessage() {} func (x *GetSandboxPolicyStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[120] + mi := &file_openshell_proto_msgTypes[139] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8918,7 +10125,7 @@ func (x *GetSandboxPolicyStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxPolicyStatusResponse.ProtoReflect.Descriptor instead. func (*GetSandboxPolicyStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{120} + return file_openshell_proto_rawDescGZIP(), []int{139} } func (x *GetSandboxPolicyStatusResponse) GetRevision() *SandboxPolicyRevision { @@ -8952,7 +10159,7 @@ type ListSandboxPoliciesRequest struct { func (x *ListSandboxPoliciesRequest) Reset() { *x = ListSandboxPoliciesRequest{} - mi := &file_openshell_proto_msgTypes[121] + mi := &file_openshell_proto_msgTypes[140] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8964,7 +10171,7 @@ func (x *ListSandboxPoliciesRequest) String() string { func (*ListSandboxPoliciesRequest) ProtoMessage() {} func (x *ListSandboxPoliciesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[121] + mi := &file_openshell_proto_msgTypes[140] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8977,7 +10184,7 @@ func (x *ListSandboxPoliciesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxPoliciesRequest.ProtoReflect.Descriptor instead. func (*ListSandboxPoliciesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{121} + return file_openshell_proto_rawDescGZIP(), []int{140} } func (x *ListSandboxPoliciesRequest) GetName() string { @@ -9025,7 +10232,7 @@ type ListSandboxPoliciesResponse struct { func (x *ListSandboxPoliciesResponse) Reset() { *x = ListSandboxPoliciesResponse{} - mi := &file_openshell_proto_msgTypes[122] + mi := &file_openshell_proto_msgTypes[141] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9037,7 +10244,7 @@ func (x *ListSandboxPoliciesResponse) String() string { func (*ListSandboxPoliciesResponse) ProtoMessage() {} func (x *ListSandboxPoliciesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[122] + mi := &file_openshell_proto_msgTypes[141] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9050,7 +10257,7 @@ func (x *ListSandboxPoliciesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxPoliciesResponse.ProtoReflect.Descriptor instead. func (*ListSandboxPoliciesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{122} + return file_openshell_proto_rawDescGZIP(), []int{141} } func (x *ListSandboxPoliciesResponse) GetRevisions() []*SandboxPolicyRevision { @@ -9077,7 +10284,7 @@ type ReportPolicyStatusRequest struct { func (x *ReportPolicyStatusRequest) Reset() { *x = ReportPolicyStatusRequest{} - mi := &file_openshell_proto_msgTypes[123] + mi := &file_openshell_proto_msgTypes[142] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9089,7 +10296,7 @@ func (x *ReportPolicyStatusRequest) String() string { func (*ReportPolicyStatusRequest) ProtoMessage() {} func (x *ReportPolicyStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[123] + mi := &file_openshell_proto_msgTypes[142] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9102,7 +10309,7 @@ func (x *ReportPolicyStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportPolicyStatusRequest.ProtoReflect.Descriptor instead. func (*ReportPolicyStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{123} + return file_openshell_proto_rawDescGZIP(), []int{142} } func (x *ReportPolicyStatusRequest) GetSandboxId() string { @@ -9142,7 +10349,7 @@ type ReportPolicyStatusResponse struct { func (x *ReportPolicyStatusResponse) Reset() { *x = ReportPolicyStatusResponse{} - mi := &file_openshell_proto_msgTypes[124] + mi := &file_openshell_proto_msgTypes[143] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9154,7 +10361,7 @@ func (x *ReportPolicyStatusResponse) String() string { func (*ReportPolicyStatusResponse) ProtoMessage() {} func (x *ReportPolicyStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[124] + mi := &file_openshell_proto_msgTypes[143] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9167,7 +10374,7 @@ func (x *ReportPolicyStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportPolicyStatusResponse.ProtoReflect.Descriptor instead. func (*ReportPolicyStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{124} + return file_openshell_proto_rawDescGZIP(), []int{143} } // A versioned policy revision with metadata. @@ -9195,7 +10402,7 @@ type SandboxPolicyRevision struct { func (x *SandboxPolicyRevision) Reset() { *x = SandboxPolicyRevision{} - mi := &file_openshell_proto_msgTypes[125] + mi := &file_openshell_proto_msgTypes[144] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9207,7 +10414,7 @@ func (x *SandboxPolicyRevision) String() string { func (*SandboxPolicyRevision) ProtoMessage() {} func (x *SandboxPolicyRevision) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[125] + mi := &file_openshell_proto_msgTypes[144] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9220,7 +10427,7 @@ func (x *SandboxPolicyRevision) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxPolicyRevision.ProtoReflect.Descriptor instead. func (*SandboxPolicyRevision) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{125} + return file_openshell_proto_rawDescGZIP(), []int{144} } func (x *SandboxPolicyRevision) GetVersion() uint32 { @@ -9300,7 +10507,7 @@ type GetSandboxLogsRequest struct { func (x *GetSandboxLogsRequest) Reset() { *x = GetSandboxLogsRequest{} - mi := &file_openshell_proto_msgTypes[126] + mi := &file_openshell_proto_msgTypes[145] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9312,7 +10519,7 @@ func (x *GetSandboxLogsRequest) String() string { func (*GetSandboxLogsRequest) ProtoMessage() {} func (x *GetSandboxLogsRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[126] + mi := &file_openshell_proto_msgTypes[145] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9325,7 +10532,7 @@ func (x *GetSandboxLogsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxLogsRequest.ProtoReflect.Descriptor instead. func (*GetSandboxLogsRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{126} + return file_openshell_proto_rawDescGZIP(), []int{145} } func (x *GetSandboxLogsRequest) GetSandboxId() string { @@ -9383,7 +10590,7 @@ type PushSandboxLogsRequest struct { func (x *PushSandboxLogsRequest) Reset() { *x = PushSandboxLogsRequest{} - mi := &file_openshell_proto_msgTypes[127] + mi := &file_openshell_proto_msgTypes[146] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9395,7 +10602,7 @@ func (x *PushSandboxLogsRequest) String() string { func (*PushSandboxLogsRequest) ProtoMessage() {} func (x *PushSandboxLogsRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[127] + mi := &file_openshell_proto_msgTypes[146] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9408,7 +10615,7 @@ func (x *PushSandboxLogsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use PushSandboxLogsRequest.ProtoReflect.Descriptor instead. func (*PushSandboxLogsRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{127} + return file_openshell_proto_rawDescGZIP(), []int{146} } func (x *PushSandboxLogsRequest) GetSandboxId() string { @@ -9434,7 +10641,7 @@ type PushSandboxLogsResponse struct { func (x *PushSandboxLogsResponse) Reset() { *x = PushSandboxLogsResponse{} - mi := &file_openshell_proto_msgTypes[128] + mi := &file_openshell_proto_msgTypes[147] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9446,7 +10653,7 @@ func (x *PushSandboxLogsResponse) String() string { func (*PushSandboxLogsResponse) ProtoMessage() {} func (x *PushSandboxLogsResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[128] + mi := &file_openshell_proto_msgTypes[147] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9459,7 +10666,7 @@ func (x *PushSandboxLogsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use PushSandboxLogsResponse.ProtoReflect.Descriptor instead. func (*PushSandboxLogsResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{128} + return file_openshell_proto_rawDescGZIP(), []int{147} } // Get sandbox logs response. @@ -9475,7 +10682,7 @@ type GetSandboxLogsResponse struct { func (x *GetSandboxLogsResponse) Reset() { *x = GetSandboxLogsResponse{} - mi := &file_openshell_proto_msgTypes[129] + mi := &file_openshell_proto_msgTypes[148] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9487,7 +10694,7 @@ func (x *GetSandboxLogsResponse) String() string { func (*GetSandboxLogsResponse) ProtoMessage() {} func (x *GetSandboxLogsResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[129] + mi := &file_openshell_proto_msgTypes[148] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9500,7 +10707,7 @@ func (x *GetSandboxLogsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxLogsResponse.ProtoReflect.Descriptor instead. func (*GetSandboxLogsResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{129} + return file_openshell_proto_rawDescGZIP(), []int{148} } func (x *GetSandboxLogsResponse) GetLogs() []*SandboxLogLine { @@ -9533,7 +10740,7 @@ type SupervisorMessage struct { func (x *SupervisorMessage) Reset() { *x = SupervisorMessage{} - mi := &file_openshell_proto_msgTypes[130] + mi := &file_openshell_proto_msgTypes[149] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9545,7 +10752,7 @@ func (x *SupervisorMessage) String() string { func (*SupervisorMessage) ProtoMessage() {} func (x *SupervisorMessage) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[130] + mi := &file_openshell_proto_msgTypes[149] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9558,7 +10765,7 @@ func (x *SupervisorMessage) ProtoReflect() protoreflect.Message { // Deprecated: Use SupervisorMessage.ProtoReflect.Descriptor instead. func (*SupervisorMessage) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{130} + return file_openshell_proto_rawDescGZIP(), []int{149} } func (x *SupervisorMessage) GetPayload() isSupervisorMessage_Payload { @@ -9649,7 +10856,7 @@ type GatewayMessage struct { func (x *GatewayMessage) Reset() { *x = GatewayMessage{} - mi := &file_openshell_proto_msgTypes[131] + mi := &file_openshell_proto_msgTypes[150] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9661,7 +10868,7 @@ func (x *GatewayMessage) String() string { func (*GatewayMessage) ProtoMessage() {} func (x *GatewayMessage) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[131] + mi := &file_openshell_proto_msgTypes[150] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9674,7 +10881,7 @@ func (x *GatewayMessage) ProtoReflect() protoreflect.Message { // Deprecated: Use GatewayMessage.ProtoReflect.Descriptor instead. func (*GatewayMessage) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{131} + return file_openshell_proto_rawDescGZIP(), []int{150} } func (x *GatewayMessage) GetPayload() isGatewayMessage_Payload { @@ -9776,7 +10983,7 @@ type SupervisorHello struct { func (x *SupervisorHello) Reset() { *x = SupervisorHello{} - mi := &file_openshell_proto_msgTypes[132] + mi := &file_openshell_proto_msgTypes[151] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9788,7 +10995,7 @@ func (x *SupervisorHello) String() string { func (*SupervisorHello) ProtoMessage() {} func (x *SupervisorHello) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[132] + mi := &file_openshell_proto_msgTypes[151] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9801,7 +11008,7 @@ func (x *SupervisorHello) ProtoReflect() protoreflect.Message { // Deprecated: Use SupervisorHello.ProtoReflect.Descriptor instead. func (*SupervisorHello) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{132} + return file_openshell_proto_rawDescGZIP(), []int{151} } func (x *SupervisorHello) GetSandboxId() string { @@ -9831,7 +11038,7 @@ type SessionAccepted struct { func (x *SessionAccepted) Reset() { *x = SessionAccepted{} - mi := &file_openshell_proto_msgTypes[133] + mi := &file_openshell_proto_msgTypes[152] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9843,7 +11050,7 @@ func (x *SessionAccepted) String() string { func (*SessionAccepted) ProtoMessage() {} func (x *SessionAccepted) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[133] + mi := &file_openshell_proto_msgTypes[152] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9856,7 +11063,7 @@ func (x *SessionAccepted) ProtoReflect() protoreflect.Message { // Deprecated: Use SessionAccepted.ProtoReflect.Descriptor instead. func (*SessionAccepted) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{133} + return file_openshell_proto_rawDescGZIP(), []int{152} } func (x *SessionAccepted) GetSessionId() string { @@ -9884,7 +11091,7 @@ type SessionRejected struct { func (x *SessionRejected) Reset() { *x = SessionRejected{} - mi := &file_openshell_proto_msgTypes[134] + mi := &file_openshell_proto_msgTypes[153] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9896,7 +11103,7 @@ func (x *SessionRejected) String() string { func (*SessionRejected) ProtoMessage() {} func (x *SessionRejected) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[134] + mi := &file_openshell_proto_msgTypes[153] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9909,7 +11116,7 @@ func (x *SessionRejected) ProtoReflect() protoreflect.Message { // Deprecated: Use SessionRejected.ProtoReflect.Descriptor instead. func (*SessionRejected) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{134} + return file_openshell_proto_rawDescGZIP(), []int{153} } func (x *SessionRejected) GetReason() string { @@ -9928,7 +11135,7 @@ type SupervisorHeartbeat struct { func (x *SupervisorHeartbeat) Reset() { *x = SupervisorHeartbeat{} - mi := &file_openshell_proto_msgTypes[135] + mi := &file_openshell_proto_msgTypes[154] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9940,7 +11147,7 @@ func (x *SupervisorHeartbeat) String() string { func (*SupervisorHeartbeat) ProtoMessage() {} func (x *SupervisorHeartbeat) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[135] + mi := &file_openshell_proto_msgTypes[154] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9953,7 +11160,7 @@ func (x *SupervisorHeartbeat) ProtoReflect() protoreflect.Message { // Deprecated: Use SupervisorHeartbeat.ProtoReflect.Descriptor instead. func (*SupervisorHeartbeat) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{135} + return file_openshell_proto_rawDescGZIP(), []int{154} } // Gateway heartbeat. @@ -9965,7 +11172,7 @@ type GatewayHeartbeat struct { func (x *GatewayHeartbeat) Reset() { *x = GatewayHeartbeat{} - mi := &file_openshell_proto_msgTypes[136] + mi := &file_openshell_proto_msgTypes[155] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9977,7 +11184,7 @@ func (x *GatewayHeartbeat) String() string { func (*GatewayHeartbeat) ProtoMessage() {} func (x *GatewayHeartbeat) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[136] + mi := &file_openshell_proto_msgTypes[155] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9990,7 +11197,7 @@ func (x *GatewayHeartbeat) ProtoReflect() protoreflect.Message { // Deprecated: Use GatewayHeartbeat.ProtoReflect.Descriptor instead. func (*GatewayHeartbeat) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{136} + return file_openshell_proto_rawDescGZIP(), []int{155} } // Terminal result reported before the supervisor shuts down. A successful RPC @@ -10007,7 +11214,7 @@ type ReportMainProcessExitRequest struct { func (x *ReportMainProcessExitRequest) Reset() { *x = ReportMainProcessExitRequest{} - mi := &file_openshell_proto_msgTypes[137] + mi := &file_openshell_proto_msgTypes[156] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10019,7 +11226,7 @@ func (x *ReportMainProcessExitRequest) String() string { func (*ReportMainProcessExitRequest) ProtoMessage() {} func (x *ReportMainProcessExitRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[137] + mi := &file_openshell_proto_msgTypes[156] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10032,7 +11239,7 @@ func (x *ReportMainProcessExitRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportMainProcessExitRequest.ProtoReflect.Descriptor instead. func (*ReportMainProcessExitRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{137} + return file_openshell_proto_rawDescGZIP(), []int{156} } func (x *ReportMainProcessExitRequest) GetSandboxId() string { @@ -10064,7 +11271,7 @@ type ReportMainProcessExitResponse struct { func (x *ReportMainProcessExitResponse) Reset() { *x = ReportMainProcessExitResponse{} - mi := &file_openshell_proto_msgTypes[138] + mi := &file_openshell_proto_msgTypes[157] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10076,7 +11283,7 @@ func (x *ReportMainProcessExitResponse) String() string { func (*ReportMainProcessExitResponse) ProtoMessage() {} func (x *ReportMainProcessExitResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[138] + mi := &file_openshell_proto_msgTypes[157] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10089,7 +11296,7 @@ func (x *ReportMainProcessExitResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportMainProcessExitResponse.ProtoReflect.Descriptor instead. func (*ReportMainProcessExitResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{138} + return file_openshell_proto_rawDescGZIP(), []int{157} } // Terminal-delivery completion reported after all expected foreground SSH @@ -10104,7 +11311,7 @@ type FinalizeMainProcessExitRequest struct { func (x *FinalizeMainProcessExitRequest) Reset() { *x = FinalizeMainProcessExitRequest{} - mi := &file_openshell_proto_msgTypes[139] + mi := &file_openshell_proto_msgTypes[158] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10116,7 +11323,7 @@ func (x *FinalizeMainProcessExitRequest) String() string { func (*FinalizeMainProcessExitRequest) ProtoMessage() {} func (x *FinalizeMainProcessExitRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[139] + mi := &file_openshell_proto_msgTypes[158] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10129,7 +11336,7 @@ func (x *FinalizeMainProcessExitRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use FinalizeMainProcessExitRequest.ProtoReflect.Descriptor instead. func (*FinalizeMainProcessExitRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{139} + return file_openshell_proto_rawDescGZIP(), []int{158} } func (x *FinalizeMainProcessExitRequest) GetSandboxId() string { @@ -10154,7 +11361,7 @@ type FinalizeMainProcessExitResponse struct { func (x *FinalizeMainProcessExitResponse) Reset() { *x = FinalizeMainProcessExitResponse{} - mi := &file_openshell_proto_msgTypes[140] + mi := &file_openshell_proto_msgTypes[159] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10166,7 +11373,7 @@ func (x *FinalizeMainProcessExitResponse) String() string { func (*FinalizeMainProcessExitResponse) ProtoMessage() {} func (x *FinalizeMainProcessExitResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[140] + mi := &file_openshell_proto_msgTypes[159] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10179,7 +11386,7 @@ func (x *FinalizeMainProcessExitResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use FinalizeMainProcessExitResponse.ProtoReflect.Descriptor instead. func (*FinalizeMainProcessExitResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{140} + return file_openshell_proto_rawDescGZIP(), []int{159} } // Gateway requests the supervisor to open a relay channel. @@ -10208,7 +11415,7 @@ type RelayOpen struct { func (x *RelayOpen) Reset() { *x = RelayOpen{} - mi := &file_openshell_proto_msgTypes[141] + mi := &file_openshell_proto_msgTypes[160] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10220,7 +11427,7 @@ func (x *RelayOpen) String() string { func (*RelayOpen) ProtoMessage() {} func (x *RelayOpen) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[141] + mi := &file_openshell_proto_msgTypes[160] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10233,7 +11440,7 @@ func (x *RelayOpen) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayOpen.ProtoReflect.Descriptor instead. func (*RelayOpen) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{141} + return file_openshell_proto_rawDescGZIP(), []int{160} } func (x *RelayOpen) GetChannelId() string { @@ -10300,7 +11507,7 @@ type SshRelayTarget struct { func (x *SshRelayTarget) Reset() { *x = SshRelayTarget{} - mi := &file_openshell_proto_msgTypes[142] + mi := &file_openshell_proto_msgTypes[161] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10312,7 +11519,7 @@ func (x *SshRelayTarget) String() string { func (*SshRelayTarget) ProtoMessage() {} func (x *SshRelayTarget) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[142] + mi := &file_openshell_proto_msgTypes[161] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10325,7 +11532,7 @@ func (x *SshRelayTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use SshRelayTarget.ProtoReflect.Descriptor instead. func (*SshRelayTarget) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{142} + return file_openshell_proto_rawDescGZIP(), []int{161} } // TCP target dialed by the supervisor from inside the sandbox. @@ -10341,7 +11548,7 @@ type TcpRelayTarget struct { func (x *TcpRelayTarget) Reset() { *x = TcpRelayTarget{} - mi := &file_openshell_proto_msgTypes[143] + mi := &file_openshell_proto_msgTypes[162] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10353,7 +11560,7 @@ func (x *TcpRelayTarget) String() string { func (*TcpRelayTarget) ProtoMessage() {} func (x *TcpRelayTarget) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[143] + mi := &file_openshell_proto_msgTypes[162] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10366,7 +11573,7 @@ func (x *TcpRelayTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use TcpRelayTarget.ProtoReflect.Descriptor instead. func (*TcpRelayTarget) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{143} + return file_openshell_proto_rawDescGZIP(), []int{162} } func (x *TcpRelayTarget) GetHost() string { @@ -10394,7 +11601,7 @@ type RelayInit struct { func (x *RelayInit) Reset() { *x = RelayInit{} - mi := &file_openshell_proto_msgTypes[144] + mi := &file_openshell_proto_msgTypes[163] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10406,7 +11613,7 @@ func (x *RelayInit) String() string { func (*RelayInit) ProtoMessage() {} func (x *RelayInit) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[144] + mi := &file_openshell_proto_msgTypes[163] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10419,7 +11626,7 @@ func (x *RelayInit) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayInit.ProtoReflect.Descriptor instead. func (*RelayInit) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{144} + return file_openshell_proto_rawDescGZIP(), []int{163} } func (x *RelayInit) GetChannelId() string { @@ -10446,7 +11653,7 @@ type RelayFrame struct { func (x *RelayFrame) Reset() { *x = RelayFrame{} - mi := &file_openshell_proto_msgTypes[145] + mi := &file_openshell_proto_msgTypes[164] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10458,7 +11665,7 @@ func (x *RelayFrame) String() string { func (*RelayFrame) ProtoMessage() {} func (x *RelayFrame) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[145] + mi := &file_openshell_proto_msgTypes[164] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10471,7 +11678,7 @@ func (x *RelayFrame) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayFrame.ProtoReflect.Descriptor instead. func (*RelayFrame) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{145} + return file_openshell_proto_rawDescGZIP(), []int{164} } func (x *RelayFrame) GetPayload() isRelayFrame_Payload { @@ -10530,7 +11737,7 @@ type RelayOpenResult struct { func (x *RelayOpenResult) Reset() { *x = RelayOpenResult{} - mi := &file_openshell_proto_msgTypes[146] + mi := &file_openshell_proto_msgTypes[165] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10542,7 +11749,7 @@ func (x *RelayOpenResult) String() string { func (*RelayOpenResult) ProtoMessage() {} func (x *RelayOpenResult) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[146] + mi := &file_openshell_proto_msgTypes[165] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10555,7 +11762,7 @@ func (x *RelayOpenResult) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayOpenResult.ProtoReflect.Descriptor instead. func (*RelayOpenResult) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{146} + return file_openshell_proto_rawDescGZIP(), []int{165} } func (x *RelayOpenResult) GetChannelId() string { @@ -10592,7 +11799,7 @@ type RelayClose struct { func (x *RelayClose) Reset() { *x = RelayClose{} - mi := &file_openshell_proto_msgTypes[147] + mi := &file_openshell_proto_msgTypes[166] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10604,7 +11811,7 @@ func (x *RelayClose) String() string { func (*RelayClose) ProtoMessage() {} func (x *RelayClose) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[147] + mi := &file_openshell_proto_msgTypes[166] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10617,7 +11824,7 @@ func (x *RelayClose) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayClose.ProtoReflect.Descriptor instead. func (*RelayClose) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{147} + return file_openshell_proto_rawDescGZIP(), []int{166} } func (x *RelayClose) GetChannelId() string { @@ -10651,7 +11858,7 @@ type L7RequestSample struct { func (x *L7RequestSample) Reset() { *x = L7RequestSample{} - mi := &file_openshell_proto_msgTypes[148] + mi := &file_openshell_proto_msgTypes[167] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10663,7 +11870,7 @@ func (x *L7RequestSample) String() string { func (*L7RequestSample) ProtoMessage() {} func (x *L7RequestSample) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[148] + mi := &file_openshell_proto_msgTypes[167] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10676,7 +11883,7 @@ func (x *L7RequestSample) ProtoReflect() protoreflect.Message { // Deprecated: Use L7RequestSample.ProtoReflect.Descriptor instead. func (*L7RequestSample) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{148} + return file_openshell_proto_rawDescGZIP(), []int{167} } func (x *L7RequestSample) GetMethod() string { @@ -10750,7 +11957,7 @@ type DenialSummary struct { func (x *DenialSummary) Reset() { *x = DenialSummary{} - mi := &file_openshell_proto_msgTypes[149] + mi := &file_openshell_proto_msgTypes[168] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10762,7 +11969,7 @@ func (x *DenialSummary) String() string { func (*DenialSummary) ProtoMessage() {} func (x *DenialSummary) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[149] + mi := &file_openshell_proto_msgTypes[168] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10775,7 +11982,7 @@ func (x *DenialSummary) ProtoReflect() protoreflect.Message { // Deprecated: Use DenialSummary.ProtoReflect.Descriptor instead. func (*DenialSummary) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{149} + return file_openshell_proto_rawDescGZIP(), []int{168} } func (x *DenialSummary) GetSandboxId() string { @@ -10910,7 +12117,7 @@ type DenialGroupCount struct { func (x *DenialGroupCount) Reset() { *x = DenialGroupCount{} - mi := &file_openshell_proto_msgTypes[150] + mi := &file_openshell_proto_msgTypes[169] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10922,7 +12129,7 @@ func (x *DenialGroupCount) String() string { func (*DenialGroupCount) ProtoMessage() {} func (x *DenialGroupCount) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[150] + mi := &file_openshell_proto_msgTypes[169] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10935,7 +12142,7 @@ func (x *DenialGroupCount) ProtoReflect() protoreflect.Message { // Deprecated: Use DenialGroupCount.ProtoReflect.Descriptor instead. func (*DenialGroupCount) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{150} + return file_openshell_proto_rawDescGZIP(), []int{169} } func (x *DenialGroupCount) GetDenyGroup() string { @@ -10968,7 +12175,7 @@ type NetworkActivitySummary struct { func (x *NetworkActivitySummary) Reset() { *x = NetworkActivitySummary{} - mi := &file_openshell_proto_msgTypes[151] + mi := &file_openshell_proto_msgTypes[170] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10980,7 +12187,7 @@ func (x *NetworkActivitySummary) String() string { func (*NetworkActivitySummary) ProtoMessage() {} func (x *NetworkActivitySummary) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[151] + mi := &file_openshell_proto_msgTypes[170] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10993,7 +12200,7 @@ func (x *NetworkActivitySummary) ProtoReflect() protoreflect.Message { // Deprecated: Use NetworkActivitySummary.ProtoReflect.Descriptor instead. func (*NetworkActivitySummary) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{151} + return file_openshell_proto_rawDescGZIP(), []int{170} } func (x *NetworkActivitySummary) GetNetworkActivityCount() uint32 { @@ -11081,7 +12288,7 @@ type PolicyChunk struct { func (x *PolicyChunk) Reset() { *x = PolicyChunk{} - mi := &file_openshell_proto_msgTypes[152] + mi := &file_openshell_proto_msgTypes[171] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11093,7 +12300,7 @@ func (x *PolicyChunk) String() string { func (*PolicyChunk) ProtoMessage() {} func (x *PolicyChunk) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[152] + mi := &file_openshell_proto_msgTypes[171] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11106,7 +12313,7 @@ func (x *PolicyChunk) ProtoReflect() protoreflect.Message { // Deprecated: Use PolicyChunk.ProtoReflect.Descriptor instead. func (*PolicyChunk) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{152} + return file_openshell_proto_rawDescGZIP(), []int{171} } func (x *PolicyChunk) GetId() string { @@ -11294,7 +12501,7 @@ type DraftPolicyUpdate struct { func (x *DraftPolicyUpdate) Reset() { *x = DraftPolicyUpdate{} - mi := &file_openshell_proto_msgTypes[153] + mi := &file_openshell_proto_msgTypes[172] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11306,7 +12513,7 @@ func (x *DraftPolicyUpdate) String() string { func (*DraftPolicyUpdate) ProtoMessage() {} func (x *DraftPolicyUpdate) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[153] + mi := &file_openshell_proto_msgTypes[172] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11319,7 +12526,7 @@ func (x *DraftPolicyUpdate) ProtoReflect() protoreflect.Message { // Deprecated: Use DraftPolicyUpdate.ProtoReflect.Descriptor instead. func (*DraftPolicyUpdate) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{153} + return file_openshell_proto_rawDescGZIP(), []int{172} } func (x *DraftPolicyUpdate) GetDraftVersion() uint64 { @@ -11377,7 +12584,7 @@ type SubmitPolicyAnalysisRequest struct { func (x *SubmitPolicyAnalysisRequest) Reset() { *x = SubmitPolicyAnalysisRequest{} - mi := &file_openshell_proto_msgTypes[154] + mi := &file_openshell_proto_msgTypes[173] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11389,7 +12596,7 @@ func (x *SubmitPolicyAnalysisRequest) String() string { func (*SubmitPolicyAnalysisRequest) ProtoMessage() {} func (x *SubmitPolicyAnalysisRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[154] + mi := &file_openshell_proto_msgTypes[173] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11402,7 +12609,7 @@ func (x *SubmitPolicyAnalysisRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SubmitPolicyAnalysisRequest.ProtoReflect.Descriptor instead. func (*SubmitPolicyAnalysisRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{154} + return file_openshell_proto_rawDescGZIP(), []int{173} } func (x *SubmitPolicyAnalysisRequest) GetSummaries() []*DenialSummary { @@ -11465,7 +12672,7 @@ type SubmitPolicyAnalysisResponse struct { func (x *SubmitPolicyAnalysisResponse) Reset() { *x = SubmitPolicyAnalysisResponse{} - mi := &file_openshell_proto_msgTypes[155] + mi := &file_openshell_proto_msgTypes[174] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11477,7 +12684,7 @@ func (x *SubmitPolicyAnalysisResponse) String() string { func (*SubmitPolicyAnalysisResponse) ProtoMessage() {} func (x *SubmitPolicyAnalysisResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[155] + mi := &file_openshell_proto_msgTypes[174] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11490,7 +12697,7 @@ func (x *SubmitPolicyAnalysisResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SubmitPolicyAnalysisResponse.ProtoReflect.Descriptor instead. func (*SubmitPolicyAnalysisResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{155} + return file_openshell_proto_rawDescGZIP(), []int{174} } func (x *SubmitPolicyAnalysisResponse) GetAcceptedChunks() uint32 { @@ -11536,7 +12743,7 @@ type GetDraftPolicyRequest struct { func (x *GetDraftPolicyRequest) Reset() { *x = GetDraftPolicyRequest{} - mi := &file_openshell_proto_msgTypes[156] + mi := &file_openshell_proto_msgTypes[175] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11548,7 +12755,7 @@ func (x *GetDraftPolicyRequest) String() string { func (*GetDraftPolicyRequest) ProtoMessage() {} func (x *GetDraftPolicyRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[156] + mi := &file_openshell_proto_msgTypes[175] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11561,7 +12768,7 @@ func (x *GetDraftPolicyRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftPolicyRequest.ProtoReflect.Descriptor instead. func (*GetDraftPolicyRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{156} + return file_openshell_proto_rawDescGZIP(), []int{175} } func (x *GetDraftPolicyRequest) GetName() string { @@ -11601,7 +12808,7 @@ type GetDraftPolicyResponse struct { func (x *GetDraftPolicyResponse) Reset() { *x = GetDraftPolicyResponse{} - mi := &file_openshell_proto_msgTypes[157] + mi := &file_openshell_proto_msgTypes[176] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11613,7 +12820,7 @@ func (x *GetDraftPolicyResponse) String() string { func (*GetDraftPolicyResponse) ProtoMessage() {} func (x *GetDraftPolicyResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[157] + mi := &file_openshell_proto_msgTypes[176] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11626,7 +12833,7 @@ func (x *GetDraftPolicyResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftPolicyResponse.ProtoReflect.Descriptor instead. func (*GetDraftPolicyResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{157} + return file_openshell_proto_rawDescGZIP(), []int{176} } func (x *GetDraftPolicyResponse) GetChunks() []*PolicyChunk { @@ -11675,7 +12882,7 @@ type ApproveDraftChunkRequest struct { func (x *ApproveDraftChunkRequest) Reset() { *x = ApproveDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[158] + mi := &file_openshell_proto_msgTypes[177] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11687,7 +12894,7 @@ func (x *ApproveDraftChunkRequest) String() string { func (*ApproveDraftChunkRequest) ProtoMessage() {} func (x *ApproveDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[158] + mi := &file_openshell_proto_msgTypes[177] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11700,7 +12907,7 @@ func (x *ApproveDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveDraftChunkRequest.ProtoReflect.Descriptor instead. func (*ApproveDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{158} + return file_openshell_proto_rawDescGZIP(), []int{177} } func (x *ApproveDraftChunkRequest) GetName() string { @@ -11743,7 +12950,7 @@ type ApproveDraftChunkResponse struct { func (x *ApproveDraftChunkResponse) Reset() { *x = ApproveDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[159] + mi := &file_openshell_proto_msgTypes[178] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11755,7 +12962,7 @@ func (x *ApproveDraftChunkResponse) String() string { func (*ApproveDraftChunkResponse) ProtoMessage() {} func (x *ApproveDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[159] + mi := &file_openshell_proto_msgTypes[178] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11768,7 +12975,7 @@ func (x *ApproveDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveDraftChunkResponse.ProtoReflect.Descriptor instead. func (*ApproveDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{159} + return file_openshell_proto_rawDescGZIP(), []int{178} } func (x *ApproveDraftChunkResponse) GetPolicyVersion() uint32 { @@ -11802,7 +13009,7 @@ type RejectDraftChunkRequest struct { func (x *RejectDraftChunkRequest) Reset() { *x = RejectDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[160] + mi := &file_openshell_proto_msgTypes[179] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11814,7 +13021,7 @@ func (x *RejectDraftChunkRequest) String() string { func (*RejectDraftChunkRequest) ProtoMessage() {} func (x *RejectDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[160] + mi := &file_openshell_proto_msgTypes[179] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11827,7 +13034,7 @@ func (x *RejectDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RejectDraftChunkRequest.ProtoReflect.Descriptor instead. func (*RejectDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{160} + return file_openshell_proto_rawDescGZIP(), []int{179} } func (x *RejectDraftChunkRequest) GetName() string { @@ -11866,7 +13073,7 @@ type RejectDraftChunkResponse struct { func (x *RejectDraftChunkResponse) Reset() { *x = RejectDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[161] + mi := &file_openshell_proto_msgTypes[180] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11878,7 +13085,7 @@ func (x *RejectDraftChunkResponse) String() string { func (*RejectDraftChunkResponse) ProtoMessage() {} func (x *RejectDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[161] + mi := &file_openshell_proto_msgTypes[180] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11891,7 +13098,7 @@ func (x *RejectDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RejectDraftChunkResponse.ProtoReflect.Descriptor instead. func (*RejectDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{161} + return file_openshell_proto_rawDescGZIP(), []int{180} } // Approve all pending chunks. @@ -11905,7 +13112,7 @@ type DraftChunkApproval struct { func (x *DraftChunkApproval) Reset() { *x = DraftChunkApproval{} - mi := &file_openshell_proto_msgTypes[162] + mi := &file_openshell_proto_msgTypes[181] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11917,7 +13124,7 @@ func (x *DraftChunkApproval) String() string { func (*DraftChunkApproval) ProtoMessage() {} func (x *DraftChunkApproval) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[162] + mi := &file_openshell_proto_msgTypes[181] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11930,7 +13137,7 @@ func (x *DraftChunkApproval) ProtoReflect() protoreflect.Message { // Deprecated: Use DraftChunkApproval.ProtoReflect.Descriptor instead. func (*DraftChunkApproval) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{162} + return file_openshell_proto_rawDescGZIP(), []int{181} } func (x *DraftChunkApproval) GetChunkId() string { @@ -11964,7 +13171,7 @@ type ApproveAllDraftChunksRequest struct { func (x *ApproveAllDraftChunksRequest) Reset() { *x = ApproveAllDraftChunksRequest{} - mi := &file_openshell_proto_msgTypes[163] + mi := &file_openshell_proto_msgTypes[182] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11976,7 +13183,7 @@ func (x *ApproveAllDraftChunksRequest) String() string { func (*ApproveAllDraftChunksRequest) ProtoMessage() {} func (x *ApproveAllDraftChunksRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[163] + mi := &file_openshell_proto_msgTypes[182] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11989,7 +13196,7 @@ func (x *ApproveAllDraftChunksRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveAllDraftChunksRequest.ProtoReflect.Descriptor instead. func (*ApproveAllDraftChunksRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{163} + return file_openshell_proto_rawDescGZIP(), []int{182} } func (x *ApproveAllDraftChunksRequest) GetName() string { @@ -12037,7 +13244,7 @@ type ApproveAllDraftChunksResponse struct { func (x *ApproveAllDraftChunksResponse) Reset() { *x = ApproveAllDraftChunksResponse{} - mi := &file_openshell_proto_msgTypes[164] + mi := &file_openshell_proto_msgTypes[183] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12049,7 +13256,7 @@ func (x *ApproveAllDraftChunksResponse) String() string { func (*ApproveAllDraftChunksResponse) ProtoMessage() {} func (x *ApproveAllDraftChunksResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[164] + mi := &file_openshell_proto_msgTypes[183] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12062,7 +13269,7 @@ func (x *ApproveAllDraftChunksResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveAllDraftChunksResponse.ProtoReflect.Descriptor instead. func (*ApproveAllDraftChunksResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{164} + return file_openshell_proto_rawDescGZIP(), []int{183} } func (x *ApproveAllDraftChunksResponse) GetPolicyVersion() uint32 { @@ -12110,7 +13317,7 @@ type EditDraftChunkRequest struct { func (x *EditDraftChunkRequest) Reset() { *x = EditDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[165] + mi := &file_openshell_proto_msgTypes[184] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12122,7 +13329,7 @@ func (x *EditDraftChunkRequest) String() string { func (*EditDraftChunkRequest) ProtoMessage() {} func (x *EditDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[165] + mi := &file_openshell_proto_msgTypes[184] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12135,7 +13342,7 @@ func (x *EditDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use EditDraftChunkRequest.ProtoReflect.Descriptor instead. func (*EditDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{165} + return file_openshell_proto_rawDescGZIP(), []int{184} } func (x *EditDraftChunkRequest) GetName() string { @@ -12174,7 +13381,7 @@ type EditDraftChunkResponse struct { func (x *EditDraftChunkResponse) Reset() { *x = EditDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[166] + mi := &file_openshell_proto_msgTypes[185] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12186,7 +13393,7 @@ func (x *EditDraftChunkResponse) String() string { func (*EditDraftChunkResponse) ProtoMessage() {} func (x *EditDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[166] + mi := &file_openshell_proto_msgTypes[185] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12199,7 +13406,7 @@ func (x *EditDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use EditDraftChunkResponse.ProtoReflect.Descriptor instead. func (*EditDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{166} + return file_openshell_proto_rawDescGZIP(), []int{185} } // Reverse an approval (remove merged rule from active policy). @@ -12217,7 +13424,7 @@ type UndoDraftChunkRequest struct { func (x *UndoDraftChunkRequest) Reset() { *x = UndoDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[167] + mi := &file_openshell_proto_msgTypes[186] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12229,7 +13436,7 @@ func (x *UndoDraftChunkRequest) String() string { func (*UndoDraftChunkRequest) ProtoMessage() {} func (x *UndoDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[167] + mi := &file_openshell_proto_msgTypes[186] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12242,7 +13449,7 @@ func (x *UndoDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UndoDraftChunkRequest.ProtoReflect.Descriptor instead. func (*UndoDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{167} + return file_openshell_proto_rawDescGZIP(), []int{186} } func (x *UndoDraftChunkRequest) GetName() string { @@ -12278,7 +13485,7 @@ type UndoDraftChunkResponse struct { func (x *UndoDraftChunkResponse) Reset() { *x = UndoDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[168] + mi := &file_openshell_proto_msgTypes[187] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12290,7 +13497,7 @@ func (x *UndoDraftChunkResponse) String() string { func (*UndoDraftChunkResponse) ProtoMessage() {} func (x *UndoDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[168] + mi := &file_openshell_proto_msgTypes[187] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12303,7 +13510,7 @@ func (x *UndoDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UndoDraftChunkResponse.ProtoReflect.Descriptor instead. func (*UndoDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{168} + return file_openshell_proto_rawDescGZIP(), []int{187} } func (x *UndoDraftChunkResponse) GetPolicyVersion() uint32 { @@ -12333,7 +13540,7 @@ type ClearDraftChunksRequest struct { func (x *ClearDraftChunksRequest) Reset() { *x = ClearDraftChunksRequest{} - mi := &file_openshell_proto_msgTypes[169] + mi := &file_openshell_proto_msgTypes[188] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12345,7 +13552,7 @@ func (x *ClearDraftChunksRequest) String() string { func (*ClearDraftChunksRequest) ProtoMessage() {} func (x *ClearDraftChunksRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[169] + mi := &file_openshell_proto_msgTypes[188] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12358,7 +13565,7 @@ func (x *ClearDraftChunksRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ClearDraftChunksRequest.ProtoReflect.Descriptor instead. func (*ClearDraftChunksRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{169} + return file_openshell_proto_rawDescGZIP(), []int{188} } func (x *ClearDraftChunksRequest) GetName() string { @@ -12385,7 +13592,7 @@ type ClearDraftChunksResponse struct { func (x *ClearDraftChunksResponse) Reset() { *x = ClearDraftChunksResponse{} - mi := &file_openshell_proto_msgTypes[170] + mi := &file_openshell_proto_msgTypes[189] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12397,7 +13604,7 @@ func (x *ClearDraftChunksResponse) String() string { func (*ClearDraftChunksResponse) ProtoMessage() {} func (x *ClearDraftChunksResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[170] + mi := &file_openshell_proto_msgTypes[189] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12410,7 +13617,7 @@ func (x *ClearDraftChunksResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ClearDraftChunksResponse.ProtoReflect.Descriptor instead. func (*ClearDraftChunksResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{170} + return file_openshell_proto_rawDescGZIP(), []int{189} } func (x *ClearDraftChunksResponse) GetChunksCleared() uint32 { @@ -12433,7 +13640,7 @@ type GetDraftHistoryRequest struct { func (x *GetDraftHistoryRequest) Reset() { *x = GetDraftHistoryRequest{} - mi := &file_openshell_proto_msgTypes[171] + mi := &file_openshell_proto_msgTypes[190] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12445,7 +13652,7 @@ func (x *GetDraftHistoryRequest) String() string { func (*GetDraftHistoryRequest) ProtoMessage() {} func (x *GetDraftHistoryRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[171] + mi := &file_openshell_proto_msgTypes[190] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12458,7 +13665,7 @@ func (x *GetDraftHistoryRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftHistoryRequest.ProtoReflect.Descriptor instead. func (*GetDraftHistoryRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{171} + return file_openshell_proto_rawDescGZIP(), []int{190} } func (x *GetDraftHistoryRequest) GetName() string { @@ -12492,7 +13699,7 @@ type DraftHistoryEntry struct { func (x *DraftHistoryEntry) Reset() { *x = DraftHistoryEntry{} - mi := &file_openshell_proto_msgTypes[172] + mi := &file_openshell_proto_msgTypes[191] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12504,7 +13711,7 @@ func (x *DraftHistoryEntry) String() string { func (*DraftHistoryEntry) ProtoMessage() {} func (x *DraftHistoryEntry) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[172] + mi := &file_openshell_proto_msgTypes[191] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12517,7 +13724,7 @@ func (x *DraftHistoryEntry) ProtoReflect() protoreflect.Message { // Deprecated: Use DraftHistoryEntry.ProtoReflect.Descriptor instead. func (*DraftHistoryEntry) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{172} + return file_openshell_proto_rawDescGZIP(), []int{191} } func (x *DraftHistoryEntry) GetTimestampMs() int64 { @@ -12558,7 +13765,7 @@ type GetDraftHistoryResponse struct { func (x *GetDraftHistoryResponse) Reset() { *x = GetDraftHistoryResponse{} - mi := &file_openshell_proto_msgTypes[173] + mi := &file_openshell_proto_msgTypes[192] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12570,7 +13777,7 @@ func (x *GetDraftHistoryResponse) String() string { func (*GetDraftHistoryResponse) ProtoMessage() {} func (x *GetDraftHistoryResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[173] + mi := &file_openshell_proto_msgTypes[192] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12583,7 +13790,7 @@ func (x *GetDraftHistoryResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftHistoryResponse.ProtoReflect.Descriptor instead. func (*GetDraftHistoryResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{173} + return file_openshell_proto_rawDescGZIP(), []int{192} } func (x *GetDraftHistoryResponse) GetEntries() []*DraftHistoryEntry { @@ -12612,7 +13819,7 @@ type PolicyRevisionPayload struct { func (x *PolicyRevisionPayload) Reset() { *x = PolicyRevisionPayload{} - mi := &file_openshell_proto_msgTypes[174] + mi := &file_openshell_proto_msgTypes[193] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12624,7 +13831,7 @@ func (x *PolicyRevisionPayload) String() string { func (*PolicyRevisionPayload) ProtoMessage() {} func (x *PolicyRevisionPayload) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[174] + mi := &file_openshell_proto_msgTypes[193] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12637,7 +13844,7 @@ func (x *PolicyRevisionPayload) ProtoReflect() protoreflect.Message { // Deprecated: Use PolicyRevisionPayload.ProtoReflect.Descriptor instead. func (*PolicyRevisionPayload) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{174} + return file_openshell_proto_rawDescGZIP(), []int{193} } func (x *PolicyRevisionPayload) GetPolicy() *sandboxv1.SandboxPolicy { @@ -12716,7 +13923,7 @@ type DraftChunkPayload struct { func (x *DraftChunkPayload) Reset() { *x = DraftChunkPayload{} - mi := &file_openshell_proto_msgTypes[175] + mi := &file_openshell_proto_msgTypes[194] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12728,7 +13935,7 @@ func (x *DraftChunkPayload) String() string { func (*DraftChunkPayload) ProtoMessage() {} func (x *DraftChunkPayload) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[175] + mi := &file_openshell_proto_msgTypes[194] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12741,7 +13948,7 @@ func (x *DraftChunkPayload) ProtoReflect() protoreflect.Message { // Deprecated: Use DraftChunkPayload.ProtoReflect.Descriptor instead. func (*DraftChunkPayload) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{175} + return file_openshell_proto_rawDescGZIP(), []int{194} } func (x *DraftChunkPayload) GetRuleName() string { @@ -12889,7 +14096,7 @@ type StoredPolicyRevision struct { func (x *StoredPolicyRevision) Reset() { *x = StoredPolicyRevision{} - mi := &file_openshell_proto_msgTypes[176] + mi := &file_openshell_proto_msgTypes[195] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12901,7 +14108,7 @@ func (x *StoredPolicyRevision) String() string { func (*StoredPolicyRevision) ProtoMessage() {} func (x *StoredPolicyRevision) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[176] + mi := &file_openshell_proto_msgTypes[195] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12914,7 +14121,7 @@ func (x *StoredPolicyRevision) ProtoReflect() protoreflect.Message { // Deprecated: Use StoredPolicyRevision.ProtoReflect.Descriptor instead. func (*StoredPolicyRevision) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{176} + return file_openshell_proto_rawDescGZIP(), []int{195} } func (x *StoredPolicyRevision) GetId() string { @@ -13023,7 +14230,7 @@ type StoredDraftChunk struct { func (x *StoredDraftChunk) Reset() { *x = StoredDraftChunk{} - mi := &file_openshell_proto_msgTypes[177] + mi := &file_openshell_proto_msgTypes[196] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13035,7 +14242,7 @@ func (x *StoredDraftChunk) String() string { func (*StoredDraftChunk) ProtoMessage() {} func (x *StoredDraftChunk) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[177] + mi := &file_openshell_proto_msgTypes[196] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13048,7 +14255,7 @@ func (x *StoredDraftChunk) ProtoReflect() protoreflect.Message { // Deprecated: Use StoredDraftChunk.ProtoReflect.Descriptor instead. func (*StoredDraftChunk) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{177} + return file_openshell_proto_rawDescGZIP(), []int{196} } func (x *StoredDraftChunk) GetId() string { @@ -13239,7 +14446,7 @@ type CreateWorkspaceRequest struct { func (x *CreateWorkspaceRequest) Reset() { *x = CreateWorkspaceRequest{} - mi := &file_openshell_proto_msgTypes[178] + mi := &file_openshell_proto_msgTypes[197] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13251,7 +14458,7 @@ func (x *CreateWorkspaceRequest) String() string { func (*CreateWorkspaceRequest) ProtoMessage() {} func (x *CreateWorkspaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[178] + mi := &file_openshell_proto_msgTypes[197] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13264,7 +14471,7 @@ func (x *CreateWorkspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateWorkspaceRequest.ProtoReflect.Descriptor instead. func (*CreateWorkspaceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{178} + return file_openshell_proto_rawDescGZIP(), []int{197} } func (x *CreateWorkspaceRequest) GetName() string { @@ -13291,7 +14498,7 @@ type CreateWorkspaceResponse struct { func (x *CreateWorkspaceResponse) Reset() { *x = CreateWorkspaceResponse{} - mi := &file_openshell_proto_msgTypes[179] + mi := &file_openshell_proto_msgTypes[198] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13303,7 +14510,7 @@ func (x *CreateWorkspaceResponse) String() string { func (*CreateWorkspaceResponse) ProtoMessage() {} func (x *CreateWorkspaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[179] + mi := &file_openshell_proto_msgTypes[198] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13316,7 +14523,7 @@ func (x *CreateWorkspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateWorkspaceResponse.ProtoReflect.Descriptor instead. func (*CreateWorkspaceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{179} + return file_openshell_proto_rawDescGZIP(), []int{198} } func (x *CreateWorkspaceResponse) GetWorkspace() *datamodelv1.Workspace { @@ -13337,7 +14544,7 @@ type GetWorkspaceRequest struct { func (x *GetWorkspaceRequest) Reset() { *x = GetWorkspaceRequest{} - mi := &file_openshell_proto_msgTypes[180] + mi := &file_openshell_proto_msgTypes[199] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13349,7 +14556,7 @@ func (x *GetWorkspaceRequest) String() string { func (*GetWorkspaceRequest) ProtoMessage() {} func (x *GetWorkspaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[180] + mi := &file_openshell_proto_msgTypes[199] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13362,7 +14569,7 @@ func (x *GetWorkspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetWorkspaceRequest.ProtoReflect.Descriptor instead. func (*GetWorkspaceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{180} + return file_openshell_proto_rawDescGZIP(), []int{199} } func (x *GetWorkspaceRequest) GetName() string { @@ -13382,7 +14589,7 @@ type GetWorkspaceResponse struct { func (x *GetWorkspaceResponse) Reset() { *x = GetWorkspaceResponse{} - mi := &file_openshell_proto_msgTypes[181] + mi := &file_openshell_proto_msgTypes[200] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13394,7 +14601,7 @@ func (x *GetWorkspaceResponse) String() string { func (*GetWorkspaceResponse) ProtoMessage() {} func (x *GetWorkspaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[181] + mi := &file_openshell_proto_msgTypes[200] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13407,7 +14614,7 @@ func (x *GetWorkspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetWorkspaceResponse.ProtoReflect.Descriptor instead. func (*GetWorkspaceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{181} + return file_openshell_proto_rawDescGZIP(), []int{200} } func (x *GetWorkspaceResponse) GetWorkspace() *datamodelv1.Workspace { @@ -13430,7 +14637,7 @@ type ListWorkspacesRequest struct { func (x *ListWorkspacesRequest) Reset() { *x = ListWorkspacesRequest{} - mi := &file_openshell_proto_msgTypes[182] + mi := &file_openshell_proto_msgTypes[201] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13442,7 +14649,7 @@ func (x *ListWorkspacesRequest) String() string { func (*ListWorkspacesRequest) ProtoMessage() {} func (x *ListWorkspacesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[182] + mi := &file_openshell_proto_msgTypes[201] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13455,7 +14662,7 @@ func (x *ListWorkspacesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspacesRequest.ProtoReflect.Descriptor instead. func (*ListWorkspacesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{182} + return file_openshell_proto_rawDescGZIP(), []int{201} } func (x *ListWorkspacesRequest) GetLimit() uint32 { @@ -13489,7 +14696,7 @@ type ListWorkspacesResponse struct { func (x *ListWorkspacesResponse) Reset() { *x = ListWorkspacesResponse{} - mi := &file_openshell_proto_msgTypes[183] + mi := &file_openshell_proto_msgTypes[202] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13501,7 +14708,7 @@ func (x *ListWorkspacesResponse) String() string { func (*ListWorkspacesResponse) ProtoMessage() {} func (x *ListWorkspacesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[183] + mi := &file_openshell_proto_msgTypes[202] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13514,7 +14721,7 @@ func (x *ListWorkspacesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspacesResponse.ProtoReflect.Descriptor instead. func (*ListWorkspacesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{183} + return file_openshell_proto_rawDescGZIP(), []int{202} } func (x *ListWorkspacesResponse) GetWorkspaces() []*datamodelv1.Workspace { @@ -13535,7 +14742,7 @@ type DeleteWorkspaceRequest struct { func (x *DeleteWorkspaceRequest) Reset() { *x = DeleteWorkspaceRequest{} - mi := &file_openshell_proto_msgTypes[184] + mi := &file_openshell_proto_msgTypes[203] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13547,7 +14754,7 @@ func (x *DeleteWorkspaceRequest) String() string { func (*DeleteWorkspaceRequest) ProtoMessage() {} func (x *DeleteWorkspaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[184] + mi := &file_openshell_proto_msgTypes[203] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13560,7 +14767,7 @@ func (x *DeleteWorkspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteWorkspaceRequest.ProtoReflect.Descriptor instead. func (*DeleteWorkspaceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{184} + return file_openshell_proto_rawDescGZIP(), []int{203} } func (x *DeleteWorkspaceRequest) GetName() string { @@ -13580,7 +14787,7 @@ type DeleteWorkspaceResponse struct { func (x *DeleteWorkspaceResponse) Reset() { *x = DeleteWorkspaceResponse{} - mi := &file_openshell_proto_msgTypes[185] + mi := &file_openshell_proto_msgTypes[204] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13592,7 +14799,7 @@ func (x *DeleteWorkspaceResponse) String() string { func (*DeleteWorkspaceResponse) ProtoMessage() {} func (x *DeleteWorkspaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[185] + mi := &file_openshell_proto_msgTypes[204] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13605,7 +14812,7 @@ func (x *DeleteWorkspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteWorkspaceResponse.ProtoReflect.Descriptor instead. func (*DeleteWorkspaceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{185} + return file_openshell_proto_rawDescGZIP(), []int{204} } func (x *DeleteWorkspaceResponse) GetDeleted() bool { @@ -13629,7 +14836,7 @@ type WorkspaceMember struct { func (x *WorkspaceMember) Reset() { *x = WorkspaceMember{} - mi := &file_openshell_proto_msgTypes[186] + mi := &file_openshell_proto_msgTypes[205] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13641,7 +14848,7 @@ func (x *WorkspaceMember) String() string { func (*WorkspaceMember) ProtoMessage() {} func (x *WorkspaceMember) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[186] + mi := &file_openshell_proto_msgTypes[205] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13654,7 +14861,7 @@ func (x *WorkspaceMember) ProtoReflect() protoreflect.Message { // Deprecated: Use WorkspaceMember.ProtoReflect.Descriptor instead. func (*WorkspaceMember) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{186} + return file_openshell_proto_rawDescGZIP(), []int{205} } func (x *WorkspaceMember) GetMetadata() *datamodelv1.ObjectMeta { @@ -13693,7 +14900,7 @@ type AddWorkspaceMemberRequest struct { func (x *AddWorkspaceMemberRequest) Reset() { *x = AddWorkspaceMemberRequest{} - mi := &file_openshell_proto_msgTypes[187] + mi := &file_openshell_proto_msgTypes[206] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13705,7 +14912,7 @@ func (x *AddWorkspaceMemberRequest) String() string { func (*AddWorkspaceMemberRequest) ProtoMessage() {} func (x *AddWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[187] + mi := &file_openshell_proto_msgTypes[206] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13718,7 +14925,7 @@ func (x *AddWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use AddWorkspaceMemberRequest.ProtoReflect.Descriptor instead. func (*AddWorkspaceMemberRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{187} + return file_openshell_proto_rawDescGZIP(), []int{206} } func (x *AddWorkspaceMemberRequest) GetWorkspace() string { @@ -13752,7 +14959,7 @@ type AddWorkspaceMemberResponse struct { func (x *AddWorkspaceMemberResponse) Reset() { *x = AddWorkspaceMemberResponse{} - mi := &file_openshell_proto_msgTypes[188] + mi := &file_openshell_proto_msgTypes[207] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13764,7 +14971,7 @@ func (x *AddWorkspaceMemberResponse) String() string { func (*AddWorkspaceMemberResponse) ProtoMessage() {} func (x *AddWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[188] + mi := &file_openshell_proto_msgTypes[207] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13777,7 +14984,7 @@ func (x *AddWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use AddWorkspaceMemberResponse.ProtoReflect.Descriptor instead. func (*AddWorkspaceMemberResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{188} + return file_openshell_proto_rawDescGZIP(), []int{207} } func (x *AddWorkspaceMemberResponse) GetMember() *WorkspaceMember { @@ -13800,7 +15007,7 @@ type RemoveWorkspaceMemberRequest struct { func (x *RemoveWorkspaceMemberRequest) Reset() { *x = RemoveWorkspaceMemberRequest{} - mi := &file_openshell_proto_msgTypes[189] + mi := &file_openshell_proto_msgTypes[208] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13812,7 +15019,7 @@ func (x *RemoveWorkspaceMemberRequest) String() string { func (*RemoveWorkspaceMemberRequest) ProtoMessage() {} func (x *RemoveWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[189] + mi := &file_openshell_proto_msgTypes[208] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13825,7 +15032,7 @@ func (x *RemoveWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveWorkspaceMemberRequest.ProtoReflect.Descriptor instead. func (*RemoveWorkspaceMemberRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{189} + return file_openshell_proto_rawDescGZIP(), []int{208} } func (x *RemoveWorkspaceMemberRequest) GetWorkspace() string { @@ -13852,7 +15059,7 @@ type RemoveWorkspaceMemberResponse struct { func (x *RemoveWorkspaceMemberResponse) Reset() { *x = RemoveWorkspaceMemberResponse{} - mi := &file_openshell_proto_msgTypes[190] + mi := &file_openshell_proto_msgTypes[209] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13864,7 +15071,7 @@ func (x *RemoveWorkspaceMemberResponse) String() string { func (*RemoveWorkspaceMemberResponse) ProtoMessage() {} func (x *RemoveWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[190] + mi := &file_openshell_proto_msgTypes[209] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13877,7 +15084,7 @@ func (x *RemoveWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveWorkspaceMemberResponse.ProtoReflect.Descriptor instead. func (*RemoveWorkspaceMemberResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{190} + return file_openshell_proto_rawDescGZIP(), []int{209} } func (x *RemoveWorkspaceMemberResponse) GetRemoved() bool { @@ -13900,7 +15107,7 @@ type ListWorkspaceMembersRequest struct { func (x *ListWorkspaceMembersRequest) Reset() { *x = ListWorkspaceMembersRequest{} - mi := &file_openshell_proto_msgTypes[191] + mi := &file_openshell_proto_msgTypes[210] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13912,7 +15119,7 @@ func (x *ListWorkspaceMembersRequest) String() string { func (*ListWorkspaceMembersRequest) ProtoMessage() {} func (x *ListWorkspaceMembersRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[191] + mi := &file_openshell_proto_msgTypes[210] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13925,7 +15132,7 @@ func (x *ListWorkspaceMembersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspaceMembersRequest.ProtoReflect.Descriptor instead. func (*ListWorkspaceMembersRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{191} + return file_openshell_proto_rawDescGZIP(), []int{210} } func (x *ListWorkspaceMembersRequest) GetWorkspace() string { @@ -13959,7 +15166,7 @@ type ListWorkspaceMembersResponse struct { func (x *ListWorkspaceMembersResponse) Reset() { *x = ListWorkspaceMembersResponse{} - mi := &file_openshell_proto_msgTypes[192] + mi := &file_openshell_proto_msgTypes[211] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13971,7 +15178,7 @@ func (x *ListWorkspaceMembersResponse) String() string { func (*ListWorkspaceMembersResponse) ProtoMessage() {} func (x *ListWorkspaceMembersResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[192] + mi := &file_openshell_proto_msgTypes[211] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13984,7 +15191,7 @@ func (x *ListWorkspaceMembersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspaceMembersResponse.ProtoReflect.Descriptor instead. func (*ListWorkspaceMembersResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{192} + return file_openshell_proto_rawDescGZIP(), []int{211} } func (x *ListWorkspaceMembersResponse) GetMembers() []*WorkspaceMember { @@ -14012,7 +15219,7 @@ type ExtensionServiceCredential struct { func (x *ExtensionServiceCredential) Reset() { *x = ExtensionServiceCredential{} - mi := &file_openshell_proto_msgTypes[193] + mi := &file_openshell_proto_msgTypes[212] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -14024,7 +15231,7 @@ func (x *ExtensionServiceCredential) String() string { func (*ExtensionServiceCredential) ProtoMessage() {} func (x *ExtensionServiceCredential) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[193] + mi := &file_openshell_proto_msgTypes[212] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -14037,7 +15244,7 @@ func (x *ExtensionServiceCredential) ProtoReflect() protoreflect.Message { // Deprecated: Use ExtensionServiceCredential.ProtoReflect.Descriptor instead. func (*ExtensionServiceCredential) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{193} + return file_openshell_proto_rawDescGZIP(), []int{212} } func (x *ExtensionServiceCredential) GetServiceName() string { @@ -14098,11 +15305,21 @@ const file_openshell_proto_rawDesc = "" + "\x19ComputeDriverCapabilities\x12\x1f\n" + "\vdriver_name\x18\x01 \x01(\tR\n" + "driverName\x12%\n" + - "\x0edriver_version\x18\x02 \x01(\tR\rdriverVersion\"\xd8\x01\n" + + "\x0edriver_version\x18\x02 \x01(\tR\rdriverVersion\"\xf2\x01\n" + "\aSandbox\x12>\n" + "\bmetadata\x18\x01 \x01(\v2\".openshell.datamodel.v1.ObjectMetaR\bmetadata\x12-\n" + "\x04spec\x18\x02 \x01(\v2\x19.openshell.v1.SandboxSpecR\x04spec\x123\n" + - "\x06status\x18\x03 \x01(\v2\x1b.openshell.v1.SandboxStatusR\x06statusJ\x04\b\x04\x10\x05J\x04\b\x05\x10\x06R\x05phaseR\x16current_policy_version\"\x83\x04\n" + + "\x06status\x18\x03 \x01(\v2\x1b.openshell.v1.SandboxStatusR\x06statusJ\x04\b\x04\x10\x05J\x04\b\x05\x10\x06J\x04\b\x06\x10\aR\x05phaseR\x16current_policy_versionR\x12delegated_identity\"\xc2\x01\n" + + "\x18SandboxDelegatedIdentity\x12#\n" + + "\rcredential_id\x18\x01 \x01(\tR\fcredentialId\x12+\n" + + "\x11principal_subject\x18\x02 \x01(\tR\x10principalSubject\x12,\n" + + "\x12delegated_until_ms\x18\x03 \x01(\x03R\x10delegatedUntilMs\x12&\n" + + "\x0fwithdrawn_at_ms\x18\x04 \x01(\x03R\rwithdrawnAtMs\"\xd6\x01\n" + + "\x1eSandboxDelegatedIdentityRecord\x12>\n" + + "\bmetadata\x18\x01 \x01(\v2\".openshell.datamodel.v1.ObjectMetaR\bmetadata\x12\x1d\n" + + "\n" + + "sandbox_id\x18\x02 \x01(\tR\tsandboxId\x12U\n" + + "\x12delegated_identity\x18\x03 \x01(\v2&.openshell.v1.SandboxDelegatedIdentityR\x11delegatedIdentity\"\x83\x04\n" + "\vSandboxSpec\x12\x1b\n" + "\tlog_level\x18\x01 \x01(\tR\blogLevel\x12L\n" + "\venvironment\x18\x05 \x03(\v2*.openshell.v1.SandboxSpec.EnvironmentEntryR\venvironment\x129\n" + @@ -14174,20 +15391,49 @@ const file_openshell_proto_rawDesc = "" + "\bmetadata\x18\x06 \x03(\v2).openshell.v1.PlatformEvent.MetadataEntryR\bmetadata\x1a;\n" + "\rMetadataEntry\x12\x10\n" + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + - "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xd4\x03\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xab\x04\n" + "\x14CreateSandboxRequest\x12-\n" + "\x04spec\x18\x01 \x01(\v2\x19.openshell.v1.SandboxSpecR\x04spec\x12\x12\n" + "\x04name\x18\x02 \x01(\tR\x04name\x12F\n" + "\x06labels\x18\x03 \x03(\v2..openshell.v1.CreateSandboxRequest.LabelsEntryR\x06labels\x12U\n" + "\vannotations\x18\x04 \x03(\v23.openshell.v1.CreateSandboxRequest.AnnotationsEntryR\vannotations\x12\x1c\n" + "\tworkspace\x18\x05 \x01(\tR\tworkspace\x12A\n" + - "\x1dawait_main_process_attachment\x18\x06 \x01(\bR\x1aawaitMainProcessAttachment\x1a9\n" + + "\x1dawait_main_process_attachment\x18\x06 \x01(\bR\x1aawaitMainProcessAttachment\x12U\n" + + "\x12delegated_identity\x18\a \x01(\v2&.openshell.v1.DelegatedIdentityRequestR\x11delegatedIdentity\x1a9\n" + "\vLabelsEntry\x12\x10\n" + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\x1a>\n" + "\x10AnnotationsEntry\x12\x10\n" + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + - "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"E\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xa7\x02\n" + + "\x18DelegatedIdentityRequest\x12,\n" + + "\x12delegated_until_ms\x18\x01 \x01(\x03R\x10delegatedUntilMs\x12\x16\n" + + "\x06issuer\x18\x02 \x01(\tR\x06issuer\x12\x1b\n" + + "\tclient_id\x18\x03 \x01(\tR\bclientId\x12)\n" + + "\rrefresh_token\x18\x04 \x01(\tB\x04\x88\xb5\x18\x01R\frefreshToken\x12'\n" + + "\faccess_token\x18\x05 \x01(\tB\x04\x88\xb5\x18\x01R\vaccessToken\x12\x16\n" + + "\x06scopes\x18\a \x01(\tR\x06scopes\x12\x1a\n" + + "\baudience\x18\b \x01(\tR\baudienceJ\x04\b\x06\x10\aR\x1aaccess_token_expires_at_ms\"\\\n" + + "(GetSandboxDelegatedIdentityStatusRequest\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\x12\x1c\n" + + "\tworkspace\x18\x02 \x01(\tR\tworkspace\"\x81\x02\n" + + ")GetSandboxDelegatedIdentityStatusResponse\x12U\n" + + "\x12delegated_identity\x18\x01 \x01(\v2&.openshell.v1.SandboxDelegatedIdentityR\x11delegatedIdentity\x12\x15\n" + + "\x06now_ms\x18\x02 \x01(\x03R\x05nowMs\x127\n" + + "\x18credential_revoked_at_ms\x18\x03 \x01(\x03R\x15credentialRevokedAtMs\x12-\n" + + "\x12credential_missing\x18\x04 \x01(\bR\x11credentialMissing\"[\n" + + "'WithdrawSandboxDelegatedIdentityRequest\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\x12\x1c\n" + + "\tworkspace\x18\x02 \x01(\tR\tworkspace\"y\n" + + "(WithdrawSandboxDelegatedIdentityResponse\x12/\n" + + "\asandbox\x18\x01 \x01(\v2\x15.openshell.v1.SandboxR\asandbox\x12\x1c\n" + + "\twithdrawn\x18\x02 \x01(\bR\twithdrawn\"\xb0\x01\n" + + "%ExtendSandboxDelegatedIdentityRequest\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\x12\x1c\n" + + "\tworkspace\x18\x02 \x01(\tR\tworkspace\x12U\n" + + "\x12delegated_identity\x18\x03 \x01(\v2&.openshell.v1.DelegatedIdentityRequestR\x11delegatedIdentity\"Y\n" + + "&ExtendSandboxDelegatedIdentityResponse\x12/\n" + + "\asandbox\x18\x01 \x01(\v2\x15.openshell.v1.SandboxR\asandbox\"E\n" + "\x11GetSandboxRequest\x12\x12\n" + "\x04name\x18\x01 \x01(\tR\x04name\x12\x1c\n" + "\tworkspace\x18\x02 \x01(\tR\tworkspace\"\xb0\x01\n" + @@ -14536,7 +15782,57 @@ const file_openshell_proto_rawDesc = "" + "\x05value\x18\x02 \x01(\v2(.openshell.datamodel.v1.CredentialHandleR\x05value:\x028\x01\"\x84\x01\n" + "\x1dStoredRefreshMaterialDeletion\x12!\n" + "\fmaterial_key\x18\x01 \x01(\tR\vmaterialKey\x12@\n" + - "\x06handle\x18\x02 \x01(\v2(.openshell.datamodel.v1.CredentialHandleR\x06handle\"\x82\x01\n" + + "\x06handle\x18\x02 \x01(\v2(.openshell.datamodel.v1.CredentialHandleR\x06handle\"\xd4\x03\n" + + "\x1bDelegatedIdentityCredential\x12>\n" + + "\bmetadata\x18\x01 \x01(\v2\".openshell.datamodel.v1.ObjectMetaR\bmetadata\x12\x16\n" + + "\x06issuer\x18\x02 \x01(\tR\x06issuer\x12\x1b\n" + + "\tclient_id\x18\x03 \x01(\tR\bclientId\x12+\n" + + "\x11principal_subject\x18\x04 \x01(\tR\x10principalSubject\x12)\n" + + "\rrefresh_token\x18\x05 \x01(\tB\x04\x88\xb5\x18\x01R\frefreshToken\x12'\n" + + "\faccess_token\x18\x06 \x01(\tB\x04\x88\xb5\x18\x01R\vaccessToken\x12:\n" + + "\x1aaccess_token_expires_at_ms\x18\a \x01(\x03R\x16accessTokenExpiresAtMs\x12\x16\n" + + "\x06scopes\x18\b \x01(\tR\x06scopes\x12\x1a\n" + + "\baudience\x18\t \x01(\tR\baudience\x12+\n" + + "\x12last_refresh_at_ms\x18\n" + + " \x01(\x03R\x0flastRefreshAtMs\x12\"\n" + + "\rrevoked_at_ms\x18\v \x01(\x03R\vrevokedAtMs\"\xed\x03\n" + + "\"DelegatedIdentityCredentialSummary\x12>\n" + + "\bmetadata\x18\x01 \x01(\v2\".openshell.datamodel.v1.ObjectMetaR\bmetadata\x12\x16\n" + + "\x06issuer\x18\x02 \x01(\tR\x06issuer\x12\x1b\n" + + "\tclient_id\x18\x03 \x01(\tR\bclientId\x12+\n" + + "\x11principal_subject\x18\x04 \x01(\tR\x10principalSubject\x122\n" + + "\x15refresh_token_present\x18\x05 \x01(\bR\x13refreshTokenPresent\x120\n" + + "\x14access_token_present\x18\x06 \x01(\bR\x12accessTokenPresent\x12:\n" + + "\x1aaccess_token_expires_at_ms\x18\a \x01(\x03R\x16accessTokenExpiresAtMs\x12\x16\n" + + "\x06scopes\x18\b \x01(\tR\x06scopes\x12\x1a\n" + + "\baudience\x18\t \x01(\tR\baudience\x12+\n" + + "\x12last_refresh_at_ms\x18\n" + + " \x01(\x03R\x0flastRefreshAtMs\x12\"\n" + + "\rrevoked_at_ms\x18\v \x01(\x03R\vrevokedAtMs\"W\n" + + "'ListDelegatedIdentityCredentialsRequest\x12\x14\n" + + "\x05limit\x18\x01 \x01(\rR\x05limit\x12\x16\n" + + "\x06offset\x18\x02 \x01(\rR\x06offset\"~\n" + + "(ListDelegatedIdentityCredentialsResponse\x12R\n" + + "\vcredentials\x18\x01 \x03(\v20.openshell.v1.DelegatedIdentityCredentialSummaryR\vcredentials\"=\n" + + "+GetDelegatedIdentityCredentialStatusRequest\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\"\x97\x01\n" + + ",GetDelegatedIdentityCredentialStatusResponse\x12P\n" + + "\n" + + "credential\x18\x01 \x01(\v20.openshell.v1.DelegatedIdentityCredentialSummaryR\n" + + "credential\x12\x15\n" + + "\x06now_ms\x18\x02 \x01(\x03R\x05nowMs\"v\n" + + "(RevokeDelegatedIdentityCredentialRequest\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12:\n" + + "\x19expected_resource_version\x18\x02 \x01(\x04R\x17expectedResourceVersion\"\x9a\x01\n" + + ")RevokeDelegatedIdentityCredentialResponse\x12\x18\n" + + "\arevoked\x18\x02 \x01(\bR\arevoked\x12\"\n" + + "\rrevoked_at_ms\x18\x03 \x01(\x03R\vrevokedAtMs\x12)\n" + + "\x10resource_version\x18\x04 \x01(\x04R\x0fresourceVersionJ\x04\b\x01\x10\x02\"v\n" + + "(DeleteDelegatedIdentityCredentialRequest\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12:\n" + + "\x19expected_resource_version\x18\x02 \x01(\x04R\x17expectedResourceVersion\"E\n" + + ")DeleteDelegatedIdentityCredentialResponse\x12\x18\n" + + "\adeleted\x18\x01 \x01(\bR\adeleted\"\x82\x01\n" + "\x1fGetProviderRefreshStatusRequest\x12\x1a\n" + "\bprovider\x18\x01 \x01(\tR\bprovider\x12%\n" + "\x0ecredential_key\x18\x02 \x01(\tR\rcredentialKey\x12\x1c\n" + @@ -15196,7 +16492,7 @@ const file_openshell_proto_rawDesc = "" + "1PROVIDER_CREDENTIAL_REFRESH_RECOVERY_ACTION_RETRY\x10\x01\x12;\n" + "7PROVIDER_CREDENTIAL_REFRESH_RECOVERY_ACTION_REAUTHORIZE\x10\x02\x12A\n" + "=PROVIDER_CREDENTIAL_REFRESH_RECOVERY_ACTION_FIX_CONFIGURATION\x10\x03\x12;\n" + - "7PROVIDER_CREDENTIAL_REFRESH_RECOVERY_ACTION_INVESTIGATE\x10\x042\xb4G\n" + + "7PROVIDER_CREDENTIAL_REFRESH_RECOVERY_ACTION_INVESTIGATE\x10\x042\xedQ\n" + "\tOpenShell\x12Z\n" + "\x06Health\x12\x1b.openshell.v1.HealthRequest\x1a\x1c.openshell.v1.HealthResponse\"\x15\x82\xb5\x18\x11\n" + "\x0funauthenticated\x12i\n" + @@ -15205,6 +16501,12 @@ const file_openshell_proto_rawDesc = "" + "\x0eGetGatewayInfo\x12#.openshell.v1.GetGatewayInfoRequest\x1a$.openshell.v1.GetGatewayInfoResponse\")\x82\xb5\x18%\n" + "\x06bearer\x1a\x0eplatform_admin\"\vconfig:read\x12u\n" + "\rCreateSandbox\x12\".openshell.v1.CreateSandboxRequest\x1a\x1d.openshell.v1.SandboxResponse\"!\x82\xb5\x18\x1d\n" + + "\x06bearer\x12\x04user\"\rsandbox:write\x12\xb6\x01\n" + + "!GetSandboxDelegatedIdentityStatus\x126.openshell.v1.GetSandboxDelegatedIdentityStatusRequest\x1a7.openshell.v1.GetSandboxDelegatedIdentityStatusResponse\" \x82\xb5\x18\x1c\n" + + "\x06bearer\x12\x04user\"\fsandbox:read\x12\xb4\x01\n" + + " WithdrawSandboxDelegatedIdentity\x125.openshell.v1.WithdrawSandboxDelegatedIdentityRequest\x1a6.openshell.v1.WithdrawSandboxDelegatedIdentityResponse\"!\x82\xb5\x18\x1d\n" + + "\x06bearer\x12\x04user\"\rsandbox:write\x12\xae\x01\n" + + "\x1eExtendSandboxDelegatedIdentity\x123.openshell.v1.ExtendSandboxDelegatedIdentityRequest\x1a4.openshell.v1.ExtendSandboxDelegatedIdentityResponse\"!\x82\xb5\x18\x1d\n" + "\x06bearer\x12\x04user\"\rsandbox:write\x12n\n" + "\n" + "GetSandbox\x12\x1f.openshell.v1.GetSandboxRequest\x1a\x1d.openshell.v1.SandboxResponse\" \x82\xb5\x18\x1c\n" + @@ -15266,7 +16568,15 @@ const file_openshell_proto_rawDesc = "" + "\x18ConfigureProviderRefresh\x12-.openshell.v1.ConfigureProviderRefreshRequest\x1a..openshell.v1.ConfigureProviderRefreshResponse\"#\x82\xb5\x18\x1f\n" + "\x06bearer\x12\x05admin\"\x0eprovider:write\x12\x9e\x01\n" + "\x18RotateProviderCredential\x12-.openshell.v1.RotateProviderCredentialRequest\x1a..openshell.v1.RotateProviderCredentialResponse\"#\x82\xb5\x18\x1f\n" + - "\x06bearer\x12\x05admin\"\x0eprovider:write\x12\x95\x01\n" + + "\x06bearer\x12\x05admin\"\x0eprovider:write\x12\xbe\x01\n" + + " ListDelegatedIdentityCredentials\x125.openshell.v1.ListDelegatedIdentityCredentialsRequest\x1a6.openshell.v1.ListDelegatedIdentityCredentialsResponse\"+\x82\xb5\x18'\n" + + "\x06bearer\x1a\x0eplatform_admin\"\rprovider:read\x12\xca\x01\n" + + "$GetDelegatedIdentityCredentialStatus\x129.openshell.v1.GetDelegatedIdentityCredentialStatusRequest\x1a:.openshell.v1.GetDelegatedIdentityCredentialStatusResponse\"+\x82\xb5\x18'\n" + + "\x06bearer\x1a\x0eplatform_admin\"\rprovider:read\x12\xc2\x01\n" + + "!RevokeDelegatedIdentityCredential\x126.openshell.v1.RevokeDelegatedIdentityCredentialRequest\x1a7.openshell.v1.RevokeDelegatedIdentityCredentialResponse\",\x82\xb5\x18(\n" + + "\x06bearer\x1a\x0eplatform_admin\"\x0eprovider:write\x12\xc2\x01\n" + + "!DeleteDelegatedIdentityCredential\x126.openshell.v1.DeleteDelegatedIdentityCredentialRequest\x1a7.openshell.v1.DeleteDelegatedIdentityCredentialResponse\",\x82\xb5\x18(\n" + + "\x06bearer\x1a\x0eplatform_admin\"\x0eprovider:write\x12\x95\x01\n" + "\x15DeleteProviderRefresh\x12*.openshell.v1.DeleteProviderRefreshRequest\x1a+.openshell.v1.DeleteProviderRefreshResponse\"#\x82\xb5\x18\x1f\n" + "\x06bearer\x12\x05admin\"\x0eprovider:write\x12\x80\x01\n" + "\x0eDeleteProvider\x12#.openshell.v1.DeleteProviderRequest\x1a$.openshell.v1.DeleteProviderResponse\"#\x82\xb5\x18\x1f\n" + @@ -15353,7 +16663,7 @@ func file_openshell_proto_rawDescGZIP() []byte { } var file_openshell_proto_enumTypes = make([]protoimpl.EnumInfo, 8) -var file_openshell_proto_msgTypes = make([]protoimpl.MessageInfo, 219) +var file_openshell_proto_msgTypes = make([]protoimpl.MessageInfo, 238) var file_openshell_proto_goTypes = []any{ (SandboxPhase)(0), // 0: openshell.v1.SandboxPhase (ProviderCredentialTokenGrantType)(0), // 1: openshell.v1.ProviderCredentialTokenGrantType @@ -15376,539 +16686,583 @@ var file_openshell_proto_goTypes = []any{ (*ComputeDriverInfo)(nil), // 18: openshell.v1.ComputeDriverInfo (*ComputeDriverCapabilities)(nil), // 19: openshell.v1.ComputeDriverCapabilities (*Sandbox)(nil), // 20: openshell.v1.Sandbox - (*SandboxSpec)(nil), // 21: openshell.v1.SandboxSpec - (*ResourceRequirements)(nil), // 22: openshell.v1.ResourceRequirements - (*GpuResourceRequirements)(nil), // 23: openshell.v1.GpuResourceRequirements - (*SandboxTemplate)(nil), // 24: openshell.v1.SandboxTemplate - (*SandboxStatus)(nil), // 25: openshell.v1.SandboxStatus - (*SandboxCondition)(nil), // 26: openshell.v1.SandboxCondition - (*PlatformEvent)(nil), // 27: openshell.v1.PlatformEvent - (*CreateSandboxRequest)(nil), // 28: openshell.v1.CreateSandboxRequest - (*GetSandboxRequest)(nil), // 29: openshell.v1.GetSandboxRequest - (*ListSandboxesRequest)(nil), // 30: openshell.v1.ListSandboxesRequest - (*ListSandboxProvidersRequest)(nil), // 31: openshell.v1.ListSandboxProvidersRequest - (*AttachSandboxProviderRequest)(nil), // 32: openshell.v1.AttachSandboxProviderRequest - (*DetachSandboxProviderRequest)(nil), // 33: openshell.v1.DetachSandboxProviderRequest - (*DeleteSandboxRequest)(nil), // 34: openshell.v1.DeleteSandboxRequest - (*StopSandboxRequest)(nil), // 35: openshell.v1.StopSandboxRequest - (*StartSandboxRequest)(nil), // 36: openshell.v1.StartSandboxRequest - (*SandboxResponse)(nil), // 37: openshell.v1.SandboxResponse - (*ListSandboxesResponse)(nil), // 38: openshell.v1.ListSandboxesResponse - (*ListSandboxProvidersResponse)(nil), // 39: openshell.v1.ListSandboxProvidersResponse - (*AttachSandboxProviderResponse)(nil), // 40: openshell.v1.AttachSandboxProviderResponse - (*DetachSandboxProviderResponse)(nil), // 41: openshell.v1.DetachSandboxProviderResponse - (*DeleteSandboxResponse)(nil), // 42: openshell.v1.DeleteSandboxResponse - (*CreateSshSessionRequest)(nil), // 43: openshell.v1.CreateSshSessionRequest - (*CreateSshSessionResponse)(nil), // 44: openshell.v1.CreateSshSessionResponse - (*ExposeServiceRequest)(nil), // 45: openshell.v1.ExposeServiceRequest - (*GetServiceRequest)(nil), // 46: openshell.v1.GetServiceRequest - (*ListServicesRequest)(nil), // 47: openshell.v1.ListServicesRequest - (*ListServicesResponse)(nil), // 48: openshell.v1.ListServicesResponse - (*DeleteServiceRequest)(nil), // 49: openshell.v1.DeleteServiceRequest - (*DeleteServiceResponse)(nil), // 50: openshell.v1.DeleteServiceResponse - (*ServiceEndpoint)(nil), // 51: openshell.v1.ServiceEndpoint - (*ServiceEndpointResponse)(nil), // 52: openshell.v1.ServiceEndpointResponse - (*RevokeSshSessionRequest)(nil), // 53: openshell.v1.RevokeSshSessionRequest - (*RevokeSshSessionResponse)(nil), // 54: openshell.v1.RevokeSshSessionResponse - (*ExecSandboxRequest)(nil), // 55: openshell.v1.ExecSandboxRequest - (*ExecSandboxStdout)(nil), // 56: openshell.v1.ExecSandboxStdout - (*ExecSandboxStderr)(nil), // 57: openshell.v1.ExecSandboxStderr - (*ExecSandboxExit)(nil), // 58: openshell.v1.ExecSandboxExit - (*ExecSandboxEvent)(nil), // 59: openshell.v1.ExecSandboxEvent - (*TcpForwardInit)(nil), // 60: openshell.v1.TcpForwardInit - (*TcpForwardFrame)(nil), // 61: openshell.v1.TcpForwardFrame - (*ExecSandboxInput)(nil), // 62: openshell.v1.ExecSandboxInput - (*ExecSandboxWindowResize)(nil), // 63: openshell.v1.ExecSandboxWindowResize - (*SshSession)(nil), // 64: openshell.v1.SshSession - (*WatchSandboxRequest)(nil), // 65: openshell.v1.WatchSandboxRequest - (*SandboxStreamEvent)(nil), // 66: openshell.v1.SandboxStreamEvent - (*SandboxLogLine)(nil), // 67: openshell.v1.SandboxLogLine - (*SandboxStreamWarning)(nil), // 68: openshell.v1.SandboxStreamWarning - (*CreateProviderRequest)(nil), // 69: openshell.v1.CreateProviderRequest - (*GetProviderRequest)(nil), // 70: openshell.v1.GetProviderRequest - (*ListProvidersRequest)(nil), // 71: openshell.v1.ListProvidersRequest - (*UpdateProviderRequest)(nil), // 72: openshell.v1.UpdateProviderRequest - (*DeleteProviderRequest)(nil), // 73: openshell.v1.DeleteProviderRequest - (*ProviderResponse)(nil), // 74: openshell.v1.ProviderResponse - (*ListProvidersResponse)(nil), // 75: openshell.v1.ListProvidersResponse - (*ListProviderProfilesRequest)(nil), // 76: openshell.v1.ListProviderProfilesRequest - (*GetProviderProfileRequest)(nil), // 77: openshell.v1.GetProviderProfileRequest - (*ProviderProfileImportItem)(nil), // 78: openshell.v1.ProviderProfileImportItem - (*ProviderProfileDiagnostic)(nil), // 79: openshell.v1.ProviderProfileDiagnostic - (*ProviderCredentialTokenGrantAudienceOverride)(nil), // 80: openshell.v1.ProviderCredentialTokenGrantAudienceOverride - (*ProviderCredentialTokenGrantSubjectToken)(nil), // 81: openshell.v1.ProviderCredentialTokenGrantSubjectToken - (*ProviderCredentialTokenGrant)(nil), // 82: openshell.v1.ProviderCredentialTokenGrant - (*ProviderProfileCredential)(nil), // 83: openshell.v1.ProviderProfileCredential - (*ProviderCredentialRefreshMaterial)(nil), // 84: openshell.v1.ProviderCredentialRefreshMaterial - (*ProviderCredentialRefreshOutput)(nil), // 85: openshell.v1.ProviderCredentialRefreshOutput - (*ProviderCredentialRefresh)(nil), // 86: openshell.v1.ProviderCredentialRefresh - (*ProviderCredentialRefreshStatus)(nil), // 87: openshell.v1.ProviderCredentialRefreshStatus - (*ProviderProfileDiscovery)(nil), // 88: openshell.v1.ProviderProfileDiscovery - (*StoredProviderCredentialRefreshState)(nil), // 89: openshell.v1.StoredProviderCredentialRefreshState - (*StoredRefreshMaterialDeletion)(nil), // 90: openshell.v1.StoredRefreshMaterialDeletion - (*GetProviderRefreshStatusRequest)(nil), // 91: openshell.v1.GetProviderRefreshStatusRequest - (*GetProviderRefreshStatusResponse)(nil), // 92: openshell.v1.GetProviderRefreshStatusResponse - (*ConfigureProviderRefreshRequest)(nil), // 93: openshell.v1.ConfigureProviderRefreshRequest - (*ConfigureProviderRefreshResponse)(nil), // 94: openshell.v1.ConfigureProviderRefreshResponse - (*RotateProviderCredentialRequest)(nil), // 95: openshell.v1.RotateProviderCredentialRequest - (*RotateProviderCredentialResponse)(nil), // 96: openshell.v1.RotateProviderCredentialResponse - (*DeleteProviderRefreshRequest)(nil), // 97: openshell.v1.DeleteProviderRefreshRequest - (*DeleteProviderRefreshResponse)(nil), // 98: openshell.v1.DeleteProviderRefreshResponse - (*ProviderProfile)(nil), // 99: openshell.v1.ProviderProfile - (*StoredProviderProfile)(nil), // 100: openshell.v1.StoredProviderProfile - (*ProviderProfileResponse)(nil), // 101: openshell.v1.ProviderProfileResponse - (*ListProviderProfilesResponse)(nil), // 102: openshell.v1.ListProviderProfilesResponse - (*ImportProviderProfilesRequest)(nil), // 103: openshell.v1.ImportProviderProfilesRequest - (*ImportProviderProfilesResponse)(nil), // 104: openshell.v1.ImportProviderProfilesResponse - (*UpdateProviderProfilesRequest)(nil), // 105: openshell.v1.UpdateProviderProfilesRequest - (*UpdateProviderProfilesResponse)(nil), // 106: openshell.v1.UpdateProviderProfilesResponse - (*LintProviderProfilesRequest)(nil), // 107: openshell.v1.LintProviderProfilesRequest - (*LintProviderProfilesResponse)(nil), // 108: openshell.v1.LintProviderProfilesResponse - (*DeleteProviderResponse)(nil), // 109: openshell.v1.DeleteProviderResponse - (*DeleteProviderProfileRequest)(nil), // 110: openshell.v1.DeleteProviderProfileRequest - (*DeleteProviderProfileResponse)(nil), // 111: openshell.v1.DeleteProviderProfileResponse - (*GetSandboxProviderEnvironmentRequest)(nil), // 112: openshell.v1.GetSandboxProviderEnvironmentRequest - (*StaticCredentialEndpointBinding)(nil), // 113: openshell.v1.StaticCredentialEndpointBinding - (*StaticCredentialBinding)(nil), // 114: openshell.v1.StaticCredentialBinding - (*GetSandboxProviderEnvironmentResponse)(nil), // 115: openshell.v1.GetSandboxProviderEnvironmentResponse - (*ExchangeProviderSubjectTokenRequest)(nil), // 116: openshell.v1.ExchangeProviderSubjectTokenRequest - (*ExchangeProviderSubjectTokenResponse)(nil), // 117: openshell.v1.ExchangeProviderSubjectTokenResponse - (*UpdateConfigRequest)(nil), // 118: openshell.v1.UpdateConfigRequest - (*PolicyMergeOperation)(nil), // 119: openshell.v1.PolicyMergeOperation - (*AddNetworkRule)(nil), // 120: openshell.v1.AddNetworkRule - (*RemoveNetworkEndpoint)(nil), // 121: openshell.v1.RemoveNetworkEndpoint - (*RemoveNetworkRule)(nil), // 122: openshell.v1.RemoveNetworkRule - (*AddDenyRules)(nil), // 123: openshell.v1.AddDenyRules - (*AddAllowRules)(nil), // 124: openshell.v1.AddAllowRules - (*RemoveNetworkBinary)(nil), // 125: openshell.v1.RemoveNetworkBinary - (*UpdateConfigResponse)(nil), // 126: openshell.v1.UpdateConfigResponse - (*GetSandboxPolicyStatusRequest)(nil), // 127: openshell.v1.GetSandboxPolicyStatusRequest - (*GetSandboxPolicyStatusResponse)(nil), // 128: openshell.v1.GetSandboxPolicyStatusResponse - (*ListSandboxPoliciesRequest)(nil), // 129: openshell.v1.ListSandboxPoliciesRequest - (*ListSandboxPoliciesResponse)(nil), // 130: openshell.v1.ListSandboxPoliciesResponse - (*ReportPolicyStatusRequest)(nil), // 131: openshell.v1.ReportPolicyStatusRequest - (*ReportPolicyStatusResponse)(nil), // 132: openshell.v1.ReportPolicyStatusResponse - (*SandboxPolicyRevision)(nil), // 133: openshell.v1.SandboxPolicyRevision - (*GetSandboxLogsRequest)(nil), // 134: openshell.v1.GetSandboxLogsRequest - (*PushSandboxLogsRequest)(nil), // 135: openshell.v1.PushSandboxLogsRequest - (*PushSandboxLogsResponse)(nil), // 136: openshell.v1.PushSandboxLogsResponse - (*GetSandboxLogsResponse)(nil), // 137: openshell.v1.GetSandboxLogsResponse - (*SupervisorMessage)(nil), // 138: openshell.v1.SupervisorMessage - (*GatewayMessage)(nil), // 139: openshell.v1.GatewayMessage - (*SupervisorHello)(nil), // 140: openshell.v1.SupervisorHello - (*SessionAccepted)(nil), // 141: openshell.v1.SessionAccepted - (*SessionRejected)(nil), // 142: openshell.v1.SessionRejected - (*SupervisorHeartbeat)(nil), // 143: openshell.v1.SupervisorHeartbeat - (*GatewayHeartbeat)(nil), // 144: openshell.v1.GatewayHeartbeat - (*ReportMainProcessExitRequest)(nil), // 145: openshell.v1.ReportMainProcessExitRequest - (*ReportMainProcessExitResponse)(nil), // 146: openshell.v1.ReportMainProcessExitResponse - (*FinalizeMainProcessExitRequest)(nil), // 147: openshell.v1.FinalizeMainProcessExitRequest - (*FinalizeMainProcessExitResponse)(nil), // 148: openshell.v1.FinalizeMainProcessExitResponse - (*RelayOpen)(nil), // 149: openshell.v1.RelayOpen - (*SshRelayTarget)(nil), // 150: openshell.v1.SshRelayTarget - (*TcpRelayTarget)(nil), // 151: openshell.v1.TcpRelayTarget - (*RelayInit)(nil), // 152: openshell.v1.RelayInit - (*RelayFrame)(nil), // 153: openshell.v1.RelayFrame - (*RelayOpenResult)(nil), // 154: openshell.v1.RelayOpenResult - (*RelayClose)(nil), // 155: openshell.v1.RelayClose - (*L7RequestSample)(nil), // 156: openshell.v1.L7RequestSample - (*DenialSummary)(nil), // 157: openshell.v1.DenialSummary - (*DenialGroupCount)(nil), // 158: openshell.v1.DenialGroupCount - (*NetworkActivitySummary)(nil), // 159: openshell.v1.NetworkActivitySummary - (*PolicyChunk)(nil), // 160: openshell.v1.PolicyChunk - (*DraftPolicyUpdate)(nil), // 161: openshell.v1.DraftPolicyUpdate - (*SubmitPolicyAnalysisRequest)(nil), // 162: openshell.v1.SubmitPolicyAnalysisRequest - (*SubmitPolicyAnalysisResponse)(nil), // 163: openshell.v1.SubmitPolicyAnalysisResponse - (*GetDraftPolicyRequest)(nil), // 164: openshell.v1.GetDraftPolicyRequest - (*GetDraftPolicyResponse)(nil), // 165: openshell.v1.GetDraftPolicyResponse - (*ApproveDraftChunkRequest)(nil), // 166: openshell.v1.ApproveDraftChunkRequest - (*ApproveDraftChunkResponse)(nil), // 167: openshell.v1.ApproveDraftChunkResponse - (*RejectDraftChunkRequest)(nil), // 168: openshell.v1.RejectDraftChunkRequest - (*RejectDraftChunkResponse)(nil), // 169: openshell.v1.RejectDraftChunkResponse - (*DraftChunkApproval)(nil), // 170: openshell.v1.DraftChunkApproval - (*ApproveAllDraftChunksRequest)(nil), // 171: openshell.v1.ApproveAllDraftChunksRequest - (*ApproveAllDraftChunksResponse)(nil), // 172: openshell.v1.ApproveAllDraftChunksResponse - (*EditDraftChunkRequest)(nil), // 173: openshell.v1.EditDraftChunkRequest - (*EditDraftChunkResponse)(nil), // 174: openshell.v1.EditDraftChunkResponse - (*UndoDraftChunkRequest)(nil), // 175: openshell.v1.UndoDraftChunkRequest - (*UndoDraftChunkResponse)(nil), // 176: openshell.v1.UndoDraftChunkResponse - (*ClearDraftChunksRequest)(nil), // 177: openshell.v1.ClearDraftChunksRequest - (*ClearDraftChunksResponse)(nil), // 178: openshell.v1.ClearDraftChunksResponse - (*GetDraftHistoryRequest)(nil), // 179: openshell.v1.GetDraftHistoryRequest - (*DraftHistoryEntry)(nil), // 180: openshell.v1.DraftHistoryEntry - (*GetDraftHistoryResponse)(nil), // 181: openshell.v1.GetDraftHistoryResponse - (*PolicyRevisionPayload)(nil), // 182: openshell.v1.PolicyRevisionPayload - (*DraftChunkPayload)(nil), // 183: openshell.v1.DraftChunkPayload - (*StoredPolicyRevision)(nil), // 184: openshell.v1.StoredPolicyRevision - (*StoredDraftChunk)(nil), // 185: openshell.v1.StoredDraftChunk - (*CreateWorkspaceRequest)(nil), // 186: openshell.v1.CreateWorkspaceRequest - (*CreateWorkspaceResponse)(nil), // 187: openshell.v1.CreateWorkspaceResponse - (*GetWorkspaceRequest)(nil), // 188: openshell.v1.GetWorkspaceRequest - (*GetWorkspaceResponse)(nil), // 189: openshell.v1.GetWorkspaceResponse - (*ListWorkspacesRequest)(nil), // 190: openshell.v1.ListWorkspacesRequest - (*ListWorkspacesResponse)(nil), // 191: openshell.v1.ListWorkspacesResponse - (*DeleteWorkspaceRequest)(nil), // 192: openshell.v1.DeleteWorkspaceRequest - (*DeleteWorkspaceResponse)(nil), // 193: openshell.v1.DeleteWorkspaceResponse - (*WorkspaceMember)(nil), // 194: openshell.v1.WorkspaceMember - (*AddWorkspaceMemberRequest)(nil), // 195: openshell.v1.AddWorkspaceMemberRequest - (*AddWorkspaceMemberResponse)(nil), // 196: openshell.v1.AddWorkspaceMemberResponse - (*RemoveWorkspaceMemberRequest)(nil), // 197: openshell.v1.RemoveWorkspaceMemberRequest - (*RemoveWorkspaceMemberResponse)(nil), // 198: openshell.v1.RemoveWorkspaceMemberResponse - (*ListWorkspaceMembersRequest)(nil), // 199: openshell.v1.ListWorkspaceMembersRequest - (*ListWorkspaceMembersResponse)(nil), // 200: openshell.v1.ListWorkspaceMembersResponse - (*ExtensionServiceCredential)(nil), // 201: openshell.v1.ExtensionServiceCredential - nil, // 202: openshell.v1.SandboxSpec.EnvironmentEntry - nil, // 203: openshell.v1.SandboxTemplate.LabelsEntry - nil, // 204: openshell.v1.SandboxTemplate.AnnotationsEntry - nil, // 205: openshell.v1.SandboxTemplate.EnvironmentEntry - nil, // 206: openshell.v1.PlatformEvent.MetadataEntry - nil, // 207: openshell.v1.CreateSandboxRequest.LabelsEntry - nil, // 208: openshell.v1.CreateSandboxRequest.AnnotationsEntry - nil, // 209: openshell.v1.ExecSandboxRequest.EnvironmentEntry - nil, // 210: openshell.v1.SandboxLogLine.FieldsEntry - nil, // 211: openshell.v1.UpdateProviderRequest.CredentialExpiresAtMsEntry - nil, // 212: openshell.v1.StoredProviderCredentialRefreshState.MaterialEntry - nil, // 213: openshell.v1.StoredProviderCredentialRefreshState.AdditionalOutputKeysEntry - nil, // 214: openshell.v1.StoredProviderCredentialRefreshState.SecretMaterialHandlesEntry - nil, // 215: openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry - nil, // 216: openshell.v1.ProviderProfile.AnnotationsEntry - nil, // 217: openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry - nil, // 218: openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpiresAtMsEntry - nil, // 219: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry - nil, // 220: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry - nil, // 221: openshell.v1.UpdateConfigRequest.AnnotationsEntry - nil, // 222: openshell.v1.UpdateConfigResponse.AnnotationsEntry - nil, // 223: openshell.v1.SandboxPolicyRevision.ProvenanceEntry - nil, // 224: openshell.v1.PolicyRevisionPayload.ProvenanceEntry - nil, // 225: openshell.v1.StoredPolicyRevision.ProvenanceEntry - nil, // 226: openshell.v1.CreateWorkspaceRequest.LabelsEntry - (*datamodelv1.ObjectMeta)(nil), // 227: openshell.datamodel.v1.ObjectMeta - (*sandboxv1.SandboxPolicy)(nil), // 228: openshell.sandbox.v1.SandboxPolicy - (*structpb.Struct)(nil), // 229: google.protobuf.Struct - (*datamodelv1.Provider)(nil), // 230: openshell.datamodel.v1.Provider - (*datamodelv1.CredentialHandle)(nil), // 231: openshell.datamodel.v1.CredentialHandle - (*sandboxv1.NetworkEndpoint)(nil), // 232: openshell.sandbox.v1.NetworkEndpoint - (*sandboxv1.NetworkBinary)(nil), // 233: openshell.sandbox.v1.NetworkBinary - (*sandboxv1.SettingValue)(nil), // 234: openshell.sandbox.v1.SettingValue - (*sandboxv1.NetworkPolicyRule)(nil), // 235: openshell.sandbox.v1.NetworkPolicyRule - (*sandboxv1.L7DenyRule)(nil), // 236: openshell.sandbox.v1.L7DenyRule - (*sandboxv1.L7Rule)(nil), // 237: openshell.sandbox.v1.L7Rule - (*datamodelv1.Workspace)(nil), // 238: openshell.datamodel.v1.Workspace - (*sandboxv1.GetSandboxConfigRequest)(nil), // 239: openshell.sandbox.v1.GetSandboxConfigRequest - (*sandboxv1.GetGatewayConfigRequest)(nil), // 240: openshell.sandbox.v1.GetGatewayConfigRequest - (*sandboxv1.GetSandboxConfigResponse)(nil), // 241: openshell.sandbox.v1.GetSandboxConfigResponse - (*sandboxv1.GetGatewayConfigResponse)(nil), // 242: openshell.sandbox.v1.GetGatewayConfigResponse + (*SandboxDelegatedIdentity)(nil), // 21: openshell.v1.SandboxDelegatedIdentity + (*SandboxDelegatedIdentityRecord)(nil), // 22: openshell.v1.SandboxDelegatedIdentityRecord + (*SandboxSpec)(nil), // 23: openshell.v1.SandboxSpec + (*ResourceRequirements)(nil), // 24: openshell.v1.ResourceRequirements + (*GpuResourceRequirements)(nil), // 25: openshell.v1.GpuResourceRequirements + (*SandboxTemplate)(nil), // 26: openshell.v1.SandboxTemplate + (*SandboxStatus)(nil), // 27: openshell.v1.SandboxStatus + (*SandboxCondition)(nil), // 28: openshell.v1.SandboxCondition + (*PlatformEvent)(nil), // 29: openshell.v1.PlatformEvent + (*CreateSandboxRequest)(nil), // 30: openshell.v1.CreateSandboxRequest + (*DelegatedIdentityRequest)(nil), // 31: openshell.v1.DelegatedIdentityRequest + (*GetSandboxDelegatedIdentityStatusRequest)(nil), // 32: openshell.v1.GetSandboxDelegatedIdentityStatusRequest + (*GetSandboxDelegatedIdentityStatusResponse)(nil), // 33: openshell.v1.GetSandboxDelegatedIdentityStatusResponse + (*WithdrawSandboxDelegatedIdentityRequest)(nil), // 34: openshell.v1.WithdrawSandboxDelegatedIdentityRequest + (*WithdrawSandboxDelegatedIdentityResponse)(nil), // 35: openshell.v1.WithdrawSandboxDelegatedIdentityResponse + (*ExtendSandboxDelegatedIdentityRequest)(nil), // 36: openshell.v1.ExtendSandboxDelegatedIdentityRequest + (*ExtendSandboxDelegatedIdentityResponse)(nil), // 37: openshell.v1.ExtendSandboxDelegatedIdentityResponse + (*GetSandboxRequest)(nil), // 38: openshell.v1.GetSandboxRequest + (*ListSandboxesRequest)(nil), // 39: openshell.v1.ListSandboxesRequest + (*ListSandboxProvidersRequest)(nil), // 40: openshell.v1.ListSandboxProvidersRequest + (*AttachSandboxProviderRequest)(nil), // 41: openshell.v1.AttachSandboxProviderRequest + (*DetachSandboxProviderRequest)(nil), // 42: openshell.v1.DetachSandboxProviderRequest + (*DeleteSandboxRequest)(nil), // 43: openshell.v1.DeleteSandboxRequest + (*StopSandboxRequest)(nil), // 44: openshell.v1.StopSandboxRequest + (*StartSandboxRequest)(nil), // 45: openshell.v1.StartSandboxRequest + (*SandboxResponse)(nil), // 46: openshell.v1.SandboxResponse + (*ListSandboxesResponse)(nil), // 47: openshell.v1.ListSandboxesResponse + (*ListSandboxProvidersResponse)(nil), // 48: openshell.v1.ListSandboxProvidersResponse + (*AttachSandboxProviderResponse)(nil), // 49: openshell.v1.AttachSandboxProviderResponse + (*DetachSandboxProviderResponse)(nil), // 50: openshell.v1.DetachSandboxProviderResponse + (*DeleteSandboxResponse)(nil), // 51: openshell.v1.DeleteSandboxResponse + (*CreateSshSessionRequest)(nil), // 52: openshell.v1.CreateSshSessionRequest + (*CreateSshSessionResponse)(nil), // 53: openshell.v1.CreateSshSessionResponse + (*ExposeServiceRequest)(nil), // 54: openshell.v1.ExposeServiceRequest + (*GetServiceRequest)(nil), // 55: openshell.v1.GetServiceRequest + (*ListServicesRequest)(nil), // 56: openshell.v1.ListServicesRequest + (*ListServicesResponse)(nil), // 57: openshell.v1.ListServicesResponse + (*DeleteServiceRequest)(nil), // 58: openshell.v1.DeleteServiceRequest + (*DeleteServiceResponse)(nil), // 59: openshell.v1.DeleteServiceResponse + (*ServiceEndpoint)(nil), // 60: openshell.v1.ServiceEndpoint + (*ServiceEndpointResponse)(nil), // 61: openshell.v1.ServiceEndpointResponse + (*RevokeSshSessionRequest)(nil), // 62: openshell.v1.RevokeSshSessionRequest + (*RevokeSshSessionResponse)(nil), // 63: openshell.v1.RevokeSshSessionResponse + (*ExecSandboxRequest)(nil), // 64: openshell.v1.ExecSandboxRequest + (*ExecSandboxStdout)(nil), // 65: openshell.v1.ExecSandboxStdout + (*ExecSandboxStderr)(nil), // 66: openshell.v1.ExecSandboxStderr + (*ExecSandboxExit)(nil), // 67: openshell.v1.ExecSandboxExit + (*ExecSandboxEvent)(nil), // 68: openshell.v1.ExecSandboxEvent + (*TcpForwardInit)(nil), // 69: openshell.v1.TcpForwardInit + (*TcpForwardFrame)(nil), // 70: openshell.v1.TcpForwardFrame + (*ExecSandboxInput)(nil), // 71: openshell.v1.ExecSandboxInput + (*ExecSandboxWindowResize)(nil), // 72: openshell.v1.ExecSandboxWindowResize + (*SshSession)(nil), // 73: openshell.v1.SshSession + (*WatchSandboxRequest)(nil), // 74: openshell.v1.WatchSandboxRequest + (*SandboxStreamEvent)(nil), // 75: openshell.v1.SandboxStreamEvent + (*SandboxLogLine)(nil), // 76: openshell.v1.SandboxLogLine + (*SandboxStreamWarning)(nil), // 77: openshell.v1.SandboxStreamWarning + (*CreateProviderRequest)(nil), // 78: openshell.v1.CreateProviderRequest + (*GetProviderRequest)(nil), // 79: openshell.v1.GetProviderRequest + (*ListProvidersRequest)(nil), // 80: openshell.v1.ListProvidersRequest + (*UpdateProviderRequest)(nil), // 81: openshell.v1.UpdateProviderRequest + (*DeleteProviderRequest)(nil), // 82: openshell.v1.DeleteProviderRequest + (*ProviderResponse)(nil), // 83: openshell.v1.ProviderResponse + (*ListProvidersResponse)(nil), // 84: openshell.v1.ListProvidersResponse + (*ListProviderProfilesRequest)(nil), // 85: openshell.v1.ListProviderProfilesRequest + (*GetProviderProfileRequest)(nil), // 86: openshell.v1.GetProviderProfileRequest + (*ProviderProfileImportItem)(nil), // 87: openshell.v1.ProviderProfileImportItem + (*ProviderProfileDiagnostic)(nil), // 88: openshell.v1.ProviderProfileDiagnostic + (*ProviderCredentialTokenGrantAudienceOverride)(nil), // 89: openshell.v1.ProviderCredentialTokenGrantAudienceOverride + (*ProviderCredentialTokenGrantSubjectToken)(nil), // 90: openshell.v1.ProviderCredentialTokenGrantSubjectToken + (*ProviderCredentialTokenGrant)(nil), // 91: openshell.v1.ProviderCredentialTokenGrant + (*ProviderProfileCredential)(nil), // 92: openshell.v1.ProviderProfileCredential + (*ProviderCredentialRefreshMaterial)(nil), // 93: openshell.v1.ProviderCredentialRefreshMaterial + (*ProviderCredentialRefreshOutput)(nil), // 94: openshell.v1.ProviderCredentialRefreshOutput + (*ProviderCredentialRefresh)(nil), // 95: openshell.v1.ProviderCredentialRefresh + (*ProviderCredentialRefreshStatus)(nil), // 96: openshell.v1.ProviderCredentialRefreshStatus + (*ProviderProfileDiscovery)(nil), // 97: openshell.v1.ProviderProfileDiscovery + (*StoredProviderCredentialRefreshState)(nil), // 98: openshell.v1.StoredProviderCredentialRefreshState + (*StoredRefreshMaterialDeletion)(nil), // 99: openshell.v1.StoredRefreshMaterialDeletion + (*DelegatedIdentityCredential)(nil), // 100: openshell.v1.DelegatedIdentityCredential + (*DelegatedIdentityCredentialSummary)(nil), // 101: openshell.v1.DelegatedIdentityCredentialSummary + (*ListDelegatedIdentityCredentialsRequest)(nil), // 102: openshell.v1.ListDelegatedIdentityCredentialsRequest + (*ListDelegatedIdentityCredentialsResponse)(nil), // 103: openshell.v1.ListDelegatedIdentityCredentialsResponse + (*GetDelegatedIdentityCredentialStatusRequest)(nil), // 104: openshell.v1.GetDelegatedIdentityCredentialStatusRequest + (*GetDelegatedIdentityCredentialStatusResponse)(nil), // 105: openshell.v1.GetDelegatedIdentityCredentialStatusResponse + (*RevokeDelegatedIdentityCredentialRequest)(nil), // 106: openshell.v1.RevokeDelegatedIdentityCredentialRequest + (*RevokeDelegatedIdentityCredentialResponse)(nil), // 107: openshell.v1.RevokeDelegatedIdentityCredentialResponse + (*DeleteDelegatedIdentityCredentialRequest)(nil), // 108: openshell.v1.DeleteDelegatedIdentityCredentialRequest + (*DeleteDelegatedIdentityCredentialResponse)(nil), // 109: openshell.v1.DeleteDelegatedIdentityCredentialResponse + (*GetProviderRefreshStatusRequest)(nil), // 110: openshell.v1.GetProviderRefreshStatusRequest + (*GetProviderRefreshStatusResponse)(nil), // 111: openshell.v1.GetProviderRefreshStatusResponse + (*ConfigureProviderRefreshRequest)(nil), // 112: openshell.v1.ConfigureProviderRefreshRequest + (*ConfigureProviderRefreshResponse)(nil), // 113: openshell.v1.ConfigureProviderRefreshResponse + (*RotateProviderCredentialRequest)(nil), // 114: openshell.v1.RotateProviderCredentialRequest + (*RotateProviderCredentialResponse)(nil), // 115: openshell.v1.RotateProviderCredentialResponse + (*DeleteProviderRefreshRequest)(nil), // 116: openshell.v1.DeleteProviderRefreshRequest + (*DeleteProviderRefreshResponse)(nil), // 117: openshell.v1.DeleteProviderRefreshResponse + (*ProviderProfile)(nil), // 118: openshell.v1.ProviderProfile + (*StoredProviderProfile)(nil), // 119: openshell.v1.StoredProviderProfile + (*ProviderProfileResponse)(nil), // 120: openshell.v1.ProviderProfileResponse + (*ListProviderProfilesResponse)(nil), // 121: openshell.v1.ListProviderProfilesResponse + (*ImportProviderProfilesRequest)(nil), // 122: openshell.v1.ImportProviderProfilesRequest + (*ImportProviderProfilesResponse)(nil), // 123: openshell.v1.ImportProviderProfilesResponse + (*UpdateProviderProfilesRequest)(nil), // 124: openshell.v1.UpdateProviderProfilesRequest + (*UpdateProviderProfilesResponse)(nil), // 125: openshell.v1.UpdateProviderProfilesResponse + (*LintProviderProfilesRequest)(nil), // 126: openshell.v1.LintProviderProfilesRequest + (*LintProviderProfilesResponse)(nil), // 127: openshell.v1.LintProviderProfilesResponse + (*DeleteProviderResponse)(nil), // 128: openshell.v1.DeleteProviderResponse + (*DeleteProviderProfileRequest)(nil), // 129: openshell.v1.DeleteProviderProfileRequest + (*DeleteProviderProfileResponse)(nil), // 130: openshell.v1.DeleteProviderProfileResponse + (*GetSandboxProviderEnvironmentRequest)(nil), // 131: openshell.v1.GetSandboxProviderEnvironmentRequest + (*StaticCredentialEndpointBinding)(nil), // 132: openshell.v1.StaticCredentialEndpointBinding + (*StaticCredentialBinding)(nil), // 133: openshell.v1.StaticCredentialBinding + (*GetSandboxProviderEnvironmentResponse)(nil), // 134: openshell.v1.GetSandboxProviderEnvironmentResponse + (*ExchangeProviderSubjectTokenRequest)(nil), // 135: openshell.v1.ExchangeProviderSubjectTokenRequest + (*ExchangeProviderSubjectTokenResponse)(nil), // 136: openshell.v1.ExchangeProviderSubjectTokenResponse + (*UpdateConfigRequest)(nil), // 137: openshell.v1.UpdateConfigRequest + (*PolicyMergeOperation)(nil), // 138: openshell.v1.PolicyMergeOperation + (*AddNetworkRule)(nil), // 139: openshell.v1.AddNetworkRule + (*RemoveNetworkEndpoint)(nil), // 140: openshell.v1.RemoveNetworkEndpoint + (*RemoveNetworkRule)(nil), // 141: openshell.v1.RemoveNetworkRule + (*AddDenyRules)(nil), // 142: openshell.v1.AddDenyRules + (*AddAllowRules)(nil), // 143: openshell.v1.AddAllowRules + (*RemoveNetworkBinary)(nil), // 144: openshell.v1.RemoveNetworkBinary + (*UpdateConfigResponse)(nil), // 145: openshell.v1.UpdateConfigResponse + (*GetSandboxPolicyStatusRequest)(nil), // 146: openshell.v1.GetSandboxPolicyStatusRequest + (*GetSandboxPolicyStatusResponse)(nil), // 147: openshell.v1.GetSandboxPolicyStatusResponse + (*ListSandboxPoliciesRequest)(nil), // 148: openshell.v1.ListSandboxPoliciesRequest + (*ListSandboxPoliciesResponse)(nil), // 149: openshell.v1.ListSandboxPoliciesResponse + (*ReportPolicyStatusRequest)(nil), // 150: openshell.v1.ReportPolicyStatusRequest + (*ReportPolicyStatusResponse)(nil), // 151: openshell.v1.ReportPolicyStatusResponse + (*SandboxPolicyRevision)(nil), // 152: openshell.v1.SandboxPolicyRevision + (*GetSandboxLogsRequest)(nil), // 153: openshell.v1.GetSandboxLogsRequest + (*PushSandboxLogsRequest)(nil), // 154: openshell.v1.PushSandboxLogsRequest + (*PushSandboxLogsResponse)(nil), // 155: openshell.v1.PushSandboxLogsResponse + (*GetSandboxLogsResponse)(nil), // 156: openshell.v1.GetSandboxLogsResponse + (*SupervisorMessage)(nil), // 157: openshell.v1.SupervisorMessage + (*GatewayMessage)(nil), // 158: openshell.v1.GatewayMessage + (*SupervisorHello)(nil), // 159: openshell.v1.SupervisorHello + (*SessionAccepted)(nil), // 160: openshell.v1.SessionAccepted + (*SessionRejected)(nil), // 161: openshell.v1.SessionRejected + (*SupervisorHeartbeat)(nil), // 162: openshell.v1.SupervisorHeartbeat + (*GatewayHeartbeat)(nil), // 163: openshell.v1.GatewayHeartbeat + (*ReportMainProcessExitRequest)(nil), // 164: openshell.v1.ReportMainProcessExitRequest + (*ReportMainProcessExitResponse)(nil), // 165: openshell.v1.ReportMainProcessExitResponse + (*FinalizeMainProcessExitRequest)(nil), // 166: openshell.v1.FinalizeMainProcessExitRequest + (*FinalizeMainProcessExitResponse)(nil), // 167: openshell.v1.FinalizeMainProcessExitResponse + (*RelayOpen)(nil), // 168: openshell.v1.RelayOpen + (*SshRelayTarget)(nil), // 169: openshell.v1.SshRelayTarget + (*TcpRelayTarget)(nil), // 170: openshell.v1.TcpRelayTarget + (*RelayInit)(nil), // 171: openshell.v1.RelayInit + (*RelayFrame)(nil), // 172: openshell.v1.RelayFrame + (*RelayOpenResult)(nil), // 173: openshell.v1.RelayOpenResult + (*RelayClose)(nil), // 174: openshell.v1.RelayClose + (*L7RequestSample)(nil), // 175: openshell.v1.L7RequestSample + (*DenialSummary)(nil), // 176: openshell.v1.DenialSummary + (*DenialGroupCount)(nil), // 177: openshell.v1.DenialGroupCount + (*NetworkActivitySummary)(nil), // 178: openshell.v1.NetworkActivitySummary + (*PolicyChunk)(nil), // 179: openshell.v1.PolicyChunk + (*DraftPolicyUpdate)(nil), // 180: openshell.v1.DraftPolicyUpdate + (*SubmitPolicyAnalysisRequest)(nil), // 181: openshell.v1.SubmitPolicyAnalysisRequest + (*SubmitPolicyAnalysisResponse)(nil), // 182: openshell.v1.SubmitPolicyAnalysisResponse + (*GetDraftPolicyRequest)(nil), // 183: openshell.v1.GetDraftPolicyRequest + (*GetDraftPolicyResponse)(nil), // 184: openshell.v1.GetDraftPolicyResponse + (*ApproveDraftChunkRequest)(nil), // 185: openshell.v1.ApproveDraftChunkRequest + (*ApproveDraftChunkResponse)(nil), // 186: openshell.v1.ApproveDraftChunkResponse + (*RejectDraftChunkRequest)(nil), // 187: openshell.v1.RejectDraftChunkRequest + (*RejectDraftChunkResponse)(nil), // 188: openshell.v1.RejectDraftChunkResponse + (*DraftChunkApproval)(nil), // 189: openshell.v1.DraftChunkApproval + (*ApproveAllDraftChunksRequest)(nil), // 190: openshell.v1.ApproveAllDraftChunksRequest + (*ApproveAllDraftChunksResponse)(nil), // 191: openshell.v1.ApproveAllDraftChunksResponse + (*EditDraftChunkRequest)(nil), // 192: openshell.v1.EditDraftChunkRequest + (*EditDraftChunkResponse)(nil), // 193: openshell.v1.EditDraftChunkResponse + (*UndoDraftChunkRequest)(nil), // 194: openshell.v1.UndoDraftChunkRequest + (*UndoDraftChunkResponse)(nil), // 195: openshell.v1.UndoDraftChunkResponse + (*ClearDraftChunksRequest)(nil), // 196: openshell.v1.ClearDraftChunksRequest + (*ClearDraftChunksResponse)(nil), // 197: openshell.v1.ClearDraftChunksResponse + (*GetDraftHistoryRequest)(nil), // 198: openshell.v1.GetDraftHistoryRequest + (*DraftHistoryEntry)(nil), // 199: openshell.v1.DraftHistoryEntry + (*GetDraftHistoryResponse)(nil), // 200: openshell.v1.GetDraftHistoryResponse + (*PolicyRevisionPayload)(nil), // 201: openshell.v1.PolicyRevisionPayload + (*DraftChunkPayload)(nil), // 202: openshell.v1.DraftChunkPayload + (*StoredPolicyRevision)(nil), // 203: openshell.v1.StoredPolicyRevision + (*StoredDraftChunk)(nil), // 204: openshell.v1.StoredDraftChunk + (*CreateWorkspaceRequest)(nil), // 205: openshell.v1.CreateWorkspaceRequest + (*CreateWorkspaceResponse)(nil), // 206: openshell.v1.CreateWorkspaceResponse + (*GetWorkspaceRequest)(nil), // 207: openshell.v1.GetWorkspaceRequest + (*GetWorkspaceResponse)(nil), // 208: openshell.v1.GetWorkspaceResponse + (*ListWorkspacesRequest)(nil), // 209: openshell.v1.ListWorkspacesRequest + (*ListWorkspacesResponse)(nil), // 210: openshell.v1.ListWorkspacesResponse + (*DeleteWorkspaceRequest)(nil), // 211: openshell.v1.DeleteWorkspaceRequest + (*DeleteWorkspaceResponse)(nil), // 212: openshell.v1.DeleteWorkspaceResponse + (*WorkspaceMember)(nil), // 213: openshell.v1.WorkspaceMember + (*AddWorkspaceMemberRequest)(nil), // 214: openshell.v1.AddWorkspaceMemberRequest + (*AddWorkspaceMemberResponse)(nil), // 215: openshell.v1.AddWorkspaceMemberResponse + (*RemoveWorkspaceMemberRequest)(nil), // 216: openshell.v1.RemoveWorkspaceMemberRequest + (*RemoveWorkspaceMemberResponse)(nil), // 217: openshell.v1.RemoveWorkspaceMemberResponse + (*ListWorkspaceMembersRequest)(nil), // 218: openshell.v1.ListWorkspaceMembersRequest + (*ListWorkspaceMembersResponse)(nil), // 219: openshell.v1.ListWorkspaceMembersResponse + (*ExtensionServiceCredential)(nil), // 220: openshell.v1.ExtensionServiceCredential + nil, // 221: openshell.v1.SandboxSpec.EnvironmentEntry + nil, // 222: openshell.v1.SandboxTemplate.LabelsEntry + nil, // 223: openshell.v1.SandboxTemplate.AnnotationsEntry + nil, // 224: openshell.v1.SandboxTemplate.EnvironmentEntry + nil, // 225: openshell.v1.PlatformEvent.MetadataEntry + nil, // 226: openshell.v1.CreateSandboxRequest.LabelsEntry + nil, // 227: openshell.v1.CreateSandboxRequest.AnnotationsEntry + nil, // 228: openshell.v1.ExecSandboxRequest.EnvironmentEntry + nil, // 229: openshell.v1.SandboxLogLine.FieldsEntry + nil, // 230: openshell.v1.UpdateProviderRequest.CredentialExpiresAtMsEntry + nil, // 231: openshell.v1.StoredProviderCredentialRefreshState.MaterialEntry + nil, // 232: openshell.v1.StoredProviderCredentialRefreshState.AdditionalOutputKeysEntry + nil, // 233: openshell.v1.StoredProviderCredentialRefreshState.SecretMaterialHandlesEntry + nil, // 234: openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry + nil, // 235: openshell.v1.ProviderProfile.AnnotationsEntry + nil, // 236: openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry + nil, // 237: openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpiresAtMsEntry + nil, // 238: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry + nil, // 239: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry + nil, // 240: openshell.v1.UpdateConfigRequest.AnnotationsEntry + nil, // 241: openshell.v1.UpdateConfigResponse.AnnotationsEntry + nil, // 242: openshell.v1.SandboxPolicyRevision.ProvenanceEntry + nil, // 243: openshell.v1.PolicyRevisionPayload.ProvenanceEntry + nil, // 244: openshell.v1.StoredPolicyRevision.ProvenanceEntry + nil, // 245: openshell.v1.CreateWorkspaceRequest.LabelsEntry + (*datamodelv1.ObjectMeta)(nil), // 246: openshell.datamodel.v1.ObjectMeta + (*sandboxv1.SandboxPolicy)(nil), // 247: openshell.sandbox.v1.SandboxPolicy + (*structpb.Struct)(nil), // 248: google.protobuf.Struct + (*datamodelv1.Provider)(nil), // 249: openshell.datamodel.v1.Provider + (*datamodelv1.CredentialHandle)(nil), // 250: openshell.datamodel.v1.CredentialHandle + (*sandboxv1.NetworkEndpoint)(nil), // 251: openshell.sandbox.v1.NetworkEndpoint + (*sandboxv1.NetworkBinary)(nil), // 252: openshell.sandbox.v1.NetworkBinary + (*sandboxv1.SettingValue)(nil), // 253: openshell.sandbox.v1.SettingValue + (*sandboxv1.NetworkPolicyRule)(nil), // 254: openshell.sandbox.v1.NetworkPolicyRule + (*sandboxv1.L7DenyRule)(nil), // 255: openshell.sandbox.v1.L7DenyRule + (*sandboxv1.L7Rule)(nil), // 256: openshell.sandbox.v1.L7Rule + (*datamodelv1.Workspace)(nil), // 257: openshell.datamodel.v1.Workspace + (*sandboxv1.GetSandboxConfigRequest)(nil), // 258: openshell.sandbox.v1.GetSandboxConfigRequest + (*sandboxv1.GetGatewayConfigRequest)(nil), // 259: openshell.sandbox.v1.GetGatewayConfigRequest + (*sandboxv1.GetSandboxConfigResponse)(nil), // 260: openshell.sandbox.v1.GetSandboxConfigResponse + (*sandboxv1.GetGatewayConfigResponse)(nil), // 261: openshell.sandbox.v1.GetGatewayConfigResponse } var file_openshell_proto_depIdxs = []int32{ - 201, // 0: openshell.v1.RefreshSandboxTokenResponse.extension_credentials:type_name -> openshell.v1.ExtensionServiceCredential + 220, // 0: openshell.v1.RefreshSandboxTokenResponse.extension_credentials:type_name -> openshell.v1.ExtensionServiceCredential 5, // 1: openshell.v1.HealthResponse.status:type_name -> openshell.v1.ServiceStatus 5, // 2: openshell.v1.GetGatewayInfoResponse.status:type_name -> openshell.v1.ServiceStatus 18, // 3: openshell.v1.GetGatewayInfoResponse.compute_drivers:type_name -> openshell.v1.ComputeDriverInfo 19, // 4: openshell.v1.ComputeDriverInfo.capabilities:type_name -> openshell.v1.ComputeDriverCapabilities - 227, // 5: openshell.v1.Sandbox.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 21, // 6: openshell.v1.Sandbox.spec:type_name -> openshell.v1.SandboxSpec - 25, // 7: openshell.v1.Sandbox.status:type_name -> openshell.v1.SandboxStatus - 202, // 8: openshell.v1.SandboxSpec.environment:type_name -> openshell.v1.SandboxSpec.EnvironmentEntry - 24, // 9: openshell.v1.SandboxSpec.template:type_name -> openshell.v1.SandboxTemplate - 228, // 10: openshell.v1.SandboxSpec.policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 22, // 11: openshell.v1.SandboxSpec.resource_requirements:type_name -> openshell.v1.ResourceRequirements - 23, // 12: openshell.v1.ResourceRequirements.gpu:type_name -> openshell.v1.GpuResourceRequirements - 203, // 13: openshell.v1.SandboxTemplate.labels:type_name -> openshell.v1.SandboxTemplate.LabelsEntry - 204, // 14: openshell.v1.SandboxTemplate.annotations:type_name -> openshell.v1.SandboxTemplate.AnnotationsEntry - 205, // 15: openshell.v1.SandboxTemplate.environment:type_name -> openshell.v1.SandboxTemplate.EnvironmentEntry - 229, // 16: openshell.v1.SandboxTemplate.resources:type_name -> google.protobuf.Struct - 229, // 17: openshell.v1.SandboxTemplate.driver_config:type_name -> google.protobuf.Struct - 26, // 18: openshell.v1.SandboxStatus.conditions:type_name -> openshell.v1.SandboxCondition - 0, // 19: openshell.v1.SandboxStatus.phase:type_name -> openshell.v1.SandboxPhase - 206, // 20: openshell.v1.PlatformEvent.metadata:type_name -> openshell.v1.PlatformEvent.MetadataEntry - 21, // 21: openshell.v1.CreateSandboxRequest.spec:type_name -> openshell.v1.SandboxSpec - 207, // 22: openshell.v1.CreateSandboxRequest.labels:type_name -> openshell.v1.CreateSandboxRequest.LabelsEntry - 208, // 23: openshell.v1.CreateSandboxRequest.annotations:type_name -> openshell.v1.CreateSandboxRequest.AnnotationsEntry - 20, // 24: openshell.v1.SandboxResponse.sandbox:type_name -> openshell.v1.Sandbox - 20, // 25: openshell.v1.ListSandboxesResponse.sandboxes:type_name -> openshell.v1.Sandbox - 230, // 26: openshell.v1.ListSandboxProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider - 20, // 27: openshell.v1.AttachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox - 20, // 28: openshell.v1.DetachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox - 52, // 29: openshell.v1.ListServicesResponse.services:type_name -> openshell.v1.ServiceEndpointResponse - 227, // 30: openshell.v1.ServiceEndpoint.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 51, // 31: openshell.v1.ServiceEndpointResponse.endpoint:type_name -> openshell.v1.ServiceEndpoint - 209, // 32: openshell.v1.ExecSandboxRequest.environment:type_name -> openshell.v1.ExecSandboxRequest.EnvironmentEntry - 56, // 33: openshell.v1.ExecSandboxEvent.stdout:type_name -> openshell.v1.ExecSandboxStdout - 57, // 34: openshell.v1.ExecSandboxEvent.stderr:type_name -> openshell.v1.ExecSandboxStderr - 58, // 35: openshell.v1.ExecSandboxEvent.exit:type_name -> openshell.v1.ExecSandboxExit - 150, // 36: openshell.v1.TcpForwardInit.ssh:type_name -> openshell.v1.SshRelayTarget - 151, // 37: openshell.v1.TcpForwardInit.tcp:type_name -> openshell.v1.TcpRelayTarget - 60, // 38: openshell.v1.TcpForwardFrame.init:type_name -> openshell.v1.TcpForwardInit - 55, // 39: openshell.v1.ExecSandboxInput.start:type_name -> openshell.v1.ExecSandboxRequest - 63, // 40: openshell.v1.ExecSandboxInput.resize:type_name -> openshell.v1.ExecSandboxWindowResize - 227, // 41: openshell.v1.SshSession.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 20, // 42: openshell.v1.SandboxStreamEvent.sandbox:type_name -> openshell.v1.Sandbox - 67, // 43: openshell.v1.SandboxStreamEvent.log:type_name -> openshell.v1.SandboxLogLine - 27, // 44: openshell.v1.SandboxStreamEvent.event:type_name -> openshell.v1.PlatformEvent - 68, // 45: openshell.v1.SandboxStreamEvent.warning:type_name -> openshell.v1.SandboxStreamWarning - 161, // 46: openshell.v1.SandboxStreamEvent.draft_policy_update:type_name -> openshell.v1.DraftPolicyUpdate - 210, // 47: openshell.v1.SandboxLogLine.fields:type_name -> openshell.v1.SandboxLogLine.FieldsEntry - 230, // 48: openshell.v1.CreateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider - 230, // 49: openshell.v1.UpdateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider - 211, // 50: openshell.v1.UpdateProviderRequest.credential_expires_at_ms:type_name -> openshell.v1.UpdateProviderRequest.CredentialExpiresAtMsEntry - 230, // 51: openshell.v1.ProviderResponse.provider:type_name -> openshell.datamodel.v1.Provider - 230, // 52: openshell.v1.ListProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider - 99, // 53: openshell.v1.ProviderProfileImportItem.profile:type_name -> openshell.v1.ProviderProfile - 80, // 54: openshell.v1.ProviderCredentialTokenGrant.audience_overrides:type_name -> openshell.v1.ProviderCredentialTokenGrantAudienceOverride - 1, // 55: openshell.v1.ProviderCredentialTokenGrant.grant_type:type_name -> openshell.v1.ProviderCredentialTokenGrantType - 81, // 56: openshell.v1.ProviderCredentialTokenGrant.subject_token:type_name -> openshell.v1.ProviderCredentialTokenGrantSubjectToken - 86, // 57: openshell.v1.ProviderProfileCredential.refresh:type_name -> openshell.v1.ProviderCredentialRefresh - 82, // 58: openshell.v1.ProviderProfileCredential.token_grant:type_name -> openshell.v1.ProviderCredentialTokenGrant - 2, // 59: openshell.v1.ProviderCredentialRefresh.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 84, // 60: openshell.v1.ProviderCredentialRefresh.material:type_name -> openshell.v1.ProviderCredentialRefreshMaterial - 85, // 61: openshell.v1.ProviderCredentialRefresh.additional_outputs:type_name -> openshell.v1.ProviderCredentialRefreshOutput - 2, // 62: openshell.v1.ProviderCredentialRefreshStatus.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 7, // 63: openshell.v1.ProviderCredentialRefreshStatus.recovery_action:type_name -> openshell.v1.ProviderCredentialRefreshRecoveryAction - 227, // 64: openshell.v1.StoredProviderCredentialRefreshState.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 2, // 65: openshell.v1.StoredProviderCredentialRefreshState.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 212, // 66: openshell.v1.StoredProviderCredentialRefreshState.material:type_name -> openshell.v1.StoredProviderCredentialRefreshState.MaterialEntry - 213, // 67: openshell.v1.StoredProviderCredentialRefreshState.additional_output_keys:type_name -> openshell.v1.StoredProviderCredentialRefreshState.AdditionalOutputKeysEntry - 214, // 68: openshell.v1.StoredProviderCredentialRefreshState.secret_material_handles:type_name -> openshell.v1.StoredProviderCredentialRefreshState.SecretMaterialHandlesEntry - 90, // 69: openshell.v1.StoredProviderCredentialRefreshState.pending_secret_deletions:type_name -> openshell.v1.StoredRefreshMaterialDeletion - 7, // 70: openshell.v1.StoredProviderCredentialRefreshState.recovery_action:type_name -> openshell.v1.ProviderCredentialRefreshRecoveryAction - 231, // 71: openshell.v1.StoredRefreshMaterialDeletion.handle:type_name -> openshell.datamodel.v1.CredentialHandle - 87, // 72: openshell.v1.GetProviderRefreshStatusResponse.credentials:type_name -> openshell.v1.ProviderCredentialRefreshStatus - 2, // 73: openshell.v1.ConfigureProviderRefreshRequest.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 215, // 74: openshell.v1.ConfigureProviderRefreshRequest.material:type_name -> openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry - 87, // 75: openshell.v1.ConfigureProviderRefreshResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus - 87, // 76: openshell.v1.RotateProviderCredentialResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus - 3, // 77: openshell.v1.ProviderProfile.category:type_name -> openshell.v1.ProviderProfileCategory - 83, // 78: openshell.v1.ProviderProfile.credentials:type_name -> openshell.v1.ProviderProfileCredential - 232, // 79: openshell.v1.ProviderProfile.endpoints:type_name -> openshell.sandbox.v1.NetworkEndpoint - 233, // 80: openshell.v1.ProviderProfile.binaries:type_name -> openshell.sandbox.v1.NetworkBinary - 88, // 81: openshell.v1.ProviderProfile.discovery:type_name -> openshell.v1.ProviderProfileDiscovery - 216, // 82: openshell.v1.ProviderProfile.annotations:type_name -> openshell.v1.ProviderProfile.AnnotationsEntry - 227, // 83: openshell.v1.StoredProviderProfile.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 99, // 84: openshell.v1.StoredProviderProfile.profile:type_name -> openshell.v1.ProviderProfile - 99, // 85: openshell.v1.ProviderProfileResponse.profile:type_name -> openshell.v1.ProviderProfile - 99, // 86: openshell.v1.ListProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile - 78, // 87: openshell.v1.ImportProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem - 79, // 88: openshell.v1.ImportProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic - 99, // 89: openshell.v1.ImportProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile - 78, // 90: openshell.v1.UpdateProviderProfilesRequest.profile:type_name -> openshell.v1.ProviderProfileImportItem - 79, // 91: openshell.v1.UpdateProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic - 99, // 92: openshell.v1.UpdateProviderProfilesResponse.profile:type_name -> openshell.v1.ProviderProfile - 78, // 93: openshell.v1.LintProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem - 79, // 94: openshell.v1.LintProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic - 113, // 95: openshell.v1.StaticCredentialBinding.endpoints:type_name -> openshell.v1.StaticCredentialEndpointBinding - 217, // 96: openshell.v1.GetSandboxProviderEnvironmentResponse.environment:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry - 218, // 97: openshell.v1.GetSandboxProviderEnvironmentResponse.credential_expires_at_ms:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpiresAtMsEntry - 219, // 98: openshell.v1.GetSandboxProviderEnvironmentResponse.dynamic_credentials:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry - 220, // 99: openshell.v1.GetSandboxProviderEnvironmentResponse.static_credential_bindings:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry - 228, // 100: openshell.v1.UpdateConfigRequest.policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 234, // 101: openshell.v1.UpdateConfigRequest.setting_value:type_name -> openshell.sandbox.v1.SettingValue - 119, // 102: openshell.v1.UpdateConfigRequest.merge_operations:type_name -> openshell.v1.PolicyMergeOperation - 221, // 103: openshell.v1.UpdateConfigRequest.annotations:type_name -> openshell.v1.UpdateConfigRequest.AnnotationsEntry - 120, // 104: openshell.v1.PolicyMergeOperation.add_rule:type_name -> openshell.v1.AddNetworkRule - 121, // 105: openshell.v1.PolicyMergeOperation.remove_endpoint:type_name -> openshell.v1.RemoveNetworkEndpoint - 122, // 106: openshell.v1.PolicyMergeOperation.remove_rule:type_name -> openshell.v1.RemoveNetworkRule - 123, // 107: openshell.v1.PolicyMergeOperation.add_deny_rules:type_name -> openshell.v1.AddDenyRules - 124, // 108: openshell.v1.PolicyMergeOperation.add_allow_rules:type_name -> openshell.v1.AddAllowRules - 125, // 109: openshell.v1.PolicyMergeOperation.remove_binary:type_name -> openshell.v1.RemoveNetworkBinary - 235, // 110: openshell.v1.AddNetworkRule.rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 236, // 111: openshell.v1.AddDenyRules.deny_rules:type_name -> openshell.sandbox.v1.L7DenyRule - 237, // 112: openshell.v1.AddAllowRules.rules:type_name -> openshell.sandbox.v1.L7Rule - 222, // 113: openshell.v1.UpdateConfigResponse.annotations:type_name -> openshell.v1.UpdateConfigResponse.AnnotationsEntry - 133, // 114: openshell.v1.GetSandboxPolicyStatusResponse.revision:type_name -> openshell.v1.SandboxPolicyRevision - 133, // 115: openshell.v1.ListSandboxPoliciesResponse.revisions:type_name -> openshell.v1.SandboxPolicyRevision - 4, // 116: openshell.v1.ReportPolicyStatusRequest.status:type_name -> openshell.v1.PolicyStatus - 4, // 117: openshell.v1.SandboxPolicyRevision.status:type_name -> openshell.v1.PolicyStatus - 228, // 118: openshell.v1.SandboxPolicyRevision.policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 223, // 119: openshell.v1.SandboxPolicyRevision.provenance:type_name -> openshell.v1.SandboxPolicyRevision.ProvenanceEntry - 67, // 120: openshell.v1.PushSandboxLogsRequest.logs:type_name -> openshell.v1.SandboxLogLine - 67, // 121: openshell.v1.GetSandboxLogsResponse.logs:type_name -> openshell.v1.SandboxLogLine - 140, // 122: openshell.v1.SupervisorMessage.hello:type_name -> openshell.v1.SupervisorHello - 143, // 123: openshell.v1.SupervisorMessage.heartbeat:type_name -> openshell.v1.SupervisorHeartbeat - 154, // 124: openshell.v1.SupervisorMessage.relay_open_result:type_name -> openshell.v1.RelayOpenResult - 155, // 125: openshell.v1.SupervisorMessage.relay_close:type_name -> openshell.v1.RelayClose - 141, // 126: openshell.v1.GatewayMessage.session_accepted:type_name -> openshell.v1.SessionAccepted - 142, // 127: openshell.v1.GatewayMessage.session_rejected:type_name -> openshell.v1.SessionRejected - 144, // 128: openshell.v1.GatewayMessage.heartbeat:type_name -> openshell.v1.GatewayHeartbeat - 149, // 129: openshell.v1.GatewayMessage.relay_open:type_name -> openshell.v1.RelayOpen - 155, // 130: openshell.v1.GatewayMessage.relay_close:type_name -> openshell.v1.RelayClose - 150, // 131: openshell.v1.RelayOpen.ssh:type_name -> openshell.v1.SshRelayTarget - 151, // 132: openshell.v1.RelayOpen.tcp:type_name -> openshell.v1.TcpRelayTarget - 152, // 133: openshell.v1.RelayFrame.init:type_name -> openshell.v1.RelayInit - 156, // 134: openshell.v1.DenialSummary.l7_request_samples:type_name -> openshell.v1.L7RequestSample - 158, // 135: openshell.v1.NetworkActivitySummary.denials_by_group:type_name -> openshell.v1.DenialGroupCount - 235, // 136: openshell.v1.PolicyChunk.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 228, // 137: openshell.v1.PolicyChunk.current_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 228, // 138: openshell.v1.PolicyChunk.candidate_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 157, // 139: openshell.v1.SubmitPolicyAnalysisRequest.summaries:type_name -> openshell.v1.DenialSummary - 160, // 140: openshell.v1.SubmitPolicyAnalysisRequest.proposed_chunks:type_name -> openshell.v1.PolicyChunk - 159, // 141: openshell.v1.SubmitPolicyAnalysisRequest.network_activity_summaries:type_name -> openshell.v1.NetworkActivitySummary - 160, // 142: openshell.v1.GetDraftPolicyResponse.chunks:type_name -> openshell.v1.PolicyChunk - 170, // 143: openshell.v1.ApproveAllDraftChunksRequest.approvals:type_name -> openshell.v1.DraftChunkApproval - 235, // 144: openshell.v1.EditDraftChunkRequest.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 180, // 145: openshell.v1.GetDraftHistoryResponse.entries:type_name -> openshell.v1.DraftHistoryEntry - 228, // 146: openshell.v1.PolicyRevisionPayload.policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 224, // 147: openshell.v1.PolicyRevisionPayload.provenance:type_name -> openshell.v1.PolicyRevisionPayload.ProvenanceEntry - 235, // 148: openshell.v1.DraftChunkPayload.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 228, // 149: openshell.v1.DraftChunkPayload.current_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 228, // 150: openshell.v1.DraftChunkPayload.candidate_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 225, // 151: openshell.v1.StoredPolicyRevision.provenance:type_name -> openshell.v1.StoredPolicyRevision.ProvenanceEntry - 228, // 152: openshell.v1.StoredDraftChunk.current_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 228, // 153: openshell.v1.StoredDraftChunk.candidate_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 226, // 154: openshell.v1.CreateWorkspaceRequest.labels:type_name -> openshell.v1.CreateWorkspaceRequest.LabelsEntry - 238, // 155: openshell.v1.CreateWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace - 238, // 156: openshell.v1.GetWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace - 238, // 157: openshell.v1.ListWorkspacesResponse.workspaces:type_name -> openshell.datamodel.v1.Workspace - 227, // 158: openshell.v1.WorkspaceMember.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 6, // 159: openshell.v1.WorkspaceMember.role:type_name -> openshell.v1.WorkspaceRole - 6, // 160: openshell.v1.AddWorkspaceMemberRequest.role:type_name -> openshell.v1.WorkspaceRole - 194, // 161: openshell.v1.AddWorkspaceMemberResponse.member:type_name -> openshell.v1.WorkspaceMember - 194, // 162: openshell.v1.ListWorkspaceMembersResponse.members:type_name -> openshell.v1.WorkspaceMember - 231, // 163: openshell.v1.StoredProviderCredentialRefreshState.SecretMaterialHandlesEntry.value:type_name -> openshell.datamodel.v1.CredentialHandle - 83, // 164: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry.value:type_name -> openshell.v1.ProviderProfileCredential - 114, // 165: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry.value:type_name -> openshell.v1.StaticCredentialBinding - 12, // 166: openshell.v1.OpenShell.Health:input_type -> openshell.v1.HealthRequest - 14, // 167: openshell.v1.OpenShell.GetCurrentUser:input_type -> openshell.v1.GetCurrentUserRequest - 16, // 168: openshell.v1.OpenShell.GetGatewayInfo:input_type -> openshell.v1.GetGatewayInfoRequest - 28, // 169: openshell.v1.OpenShell.CreateSandbox:input_type -> openshell.v1.CreateSandboxRequest - 29, // 170: openshell.v1.OpenShell.GetSandbox:input_type -> openshell.v1.GetSandboxRequest - 30, // 171: openshell.v1.OpenShell.ListSandboxes:input_type -> openshell.v1.ListSandboxesRequest - 31, // 172: openshell.v1.OpenShell.ListSandboxProviders:input_type -> openshell.v1.ListSandboxProvidersRequest - 32, // 173: openshell.v1.OpenShell.AttachSandboxProvider:input_type -> openshell.v1.AttachSandboxProviderRequest - 33, // 174: openshell.v1.OpenShell.DetachSandboxProvider:input_type -> openshell.v1.DetachSandboxProviderRequest - 34, // 175: openshell.v1.OpenShell.DeleteSandbox:input_type -> openshell.v1.DeleteSandboxRequest - 35, // 176: openshell.v1.OpenShell.StopSandbox:input_type -> openshell.v1.StopSandboxRequest - 36, // 177: openshell.v1.OpenShell.StartSandbox:input_type -> openshell.v1.StartSandboxRequest - 43, // 178: openshell.v1.OpenShell.CreateSshSession:input_type -> openshell.v1.CreateSshSessionRequest - 45, // 179: openshell.v1.OpenShell.ExposeService:input_type -> openshell.v1.ExposeServiceRequest - 46, // 180: openshell.v1.OpenShell.GetService:input_type -> openshell.v1.GetServiceRequest - 47, // 181: openshell.v1.OpenShell.ListServices:input_type -> openshell.v1.ListServicesRequest - 49, // 182: openshell.v1.OpenShell.DeleteService:input_type -> openshell.v1.DeleteServiceRequest - 53, // 183: openshell.v1.OpenShell.RevokeSshSession:input_type -> openshell.v1.RevokeSshSessionRequest - 55, // 184: openshell.v1.OpenShell.ExecSandbox:input_type -> openshell.v1.ExecSandboxRequest - 61, // 185: openshell.v1.OpenShell.ForwardTcp:input_type -> openshell.v1.TcpForwardFrame - 62, // 186: openshell.v1.OpenShell.ExecSandboxInteractive:input_type -> openshell.v1.ExecSandboxInput - 69, // 187: openshell.v1.OpenShell.CreateProvider:input_type -> openshell.v1.CreateProviderRequest - 70, // 188: openshell.v1.OpenShell.GetProvider:input_type -> openshell.v1.GetProviderRequest - 71, // 189: openshell.v1.OpenShell.ListProviders:input_type -> openshell.v1.ListProvidersRequest - 76, // 190: openshell.v1.OpenShell.ListProviderProfiles:input_type -> openshell.v1.ListProviderProfilesRequest - 77, // 191: openshell.v1.OpenShell.GetProviderProfile:input_type -> openshell.v1.GetProviderProfileRequest - 103, // 192: openshell.v1.OpenShell.ImportProviderProfiles:input_type -> openshell.v1.ImportProviderProfilesRequest - 105, // 193: openshell.v1.OpenShell.UpdateProviderProfiles:input_type -> openshell.v1.UpdateProviderProfilesRequest - 107, // 194: openshell.v1.OpenShell.LintProviderProfiles:input_type -> openshell.v1.LintProviderProfilesRequest - 72, // 195: openshell.v1.OpenShell.UpdateProvider:input_type -> openshell.v1.UpdateProviderRequest - 91, // 196: openshell.v1.OpenShell.GetProviderRefreshStatus:input_type -> openshell.v1.GetProviderRefreshStatusRequest - 93, // 197: openshell.v1.OpenShell.ConfigureProviderRefresh:input_type -> openshell.v1.ConfigureProviderRefreshRequest - 95, // 198: openshell.v1.OpenShell.RotateProviderCredential:input_type -> openshell.v1.RotateProviderCredentialRequest - 97, // 199: openshell.v1.OpenShell.DeleteProviderRefresh:input_type -> openshell.v1.DeleteProviderRefreshRequest - 73, // 200: openshell.v1.OpenShell.DeleteProvider:input_type -> openshell.v1.DeleteProviderRequest - 110, // 201: openshell.v1.OpenShell.DeleteProviderProfile:input_type -> openshell.v1.DeleteProviderProfileRequest - 239, // 202: openshell.v1.OpenShell.GetSandboxConfig:input_type -> openshell.sandbox.v1.GetSandboxConfigRequest - 240, // 203: openshell.v1.OpenShell.GetGatewayConfig:input_type -> openshell.sandbox.v1.GetGatewayConfigRequest - 118, // 204: openshell.v1.OpenShell.UpdateConfig:input_type -> openshell.v1.UpdateConfigRequest - 127, // 205: openshell.v1.OpenShell.GetSandboxPolicyStatus:input_type -> openshell.v1.GetSandboxPolicyStatusRequest - 129, // 206: openshell.v1.OpenShell.ListSandboxPolicies:input_type -> openshell.v1.ListSandboxPoliciesRequest - 131, // 207: openshell.v1.OpenShell.ReportPolicyStatus:input_type -> openshell.v1.ReportPolicyStatusRequest - 112, // 208: openshell.v1.OpenShell.GetSandboxProviderEnvironment:input_type -> openshell.v1.GetSandboxProviderEnvironmentRequest - 116, // 209: openshell.v1.OpenShell.ExchangeProviderSubjectToken:input_type -> openshell.v1.ExchangeProviderSubjectTokenRequest - 134, // 210: openshell.v1.OpenShell.GetSandboxLogs:input_type -> openshell.v1.GetSandboxLogsRequest - 135, // 211: openshell.v1.OpenShell.PushSandboxLogs:input_type -> openshell.v1.PushSandboxLogsRequest - 138, // 212: openshell.v1.OpenShell.ConnectSupervisor:input_type -> openshell.v1.SupervisorMessage - 145, // 213: openshell.v1.OpenShell.ReportMainProcessExit:input_type -> openshell.v1.ReportMainProcessExitRequest - 147, // 214: openshell.v1.OpenShell.FinalizeMainProcessExit:input_type -> openshell.v1.FinalizeMainProcessExitRequest - 153, // 215: openshell.v1.OpenShell.RelayStream:input_type -> openshell.v1.RelayFrame - 65, // 216: openshell.v1.OpenShell.WatchSandbox:input_type -> openshell.v1.WatchSandboxRequest - 162, // 217: openshell.v1.OpenShell.SubmitPolicyAnalysis:input_type -> openshell.v1.SubmitPolicyAnalysisRequest - 164, // 218: openshell.v1.OpenShell.GetDraftPolicy:input_type -> openshell.v1.GetDraftPolicyRequest - 166, // 219: openshell.v1.OpenShell.ApproveDraftChunk:input_type -> openshell.v1.ApproveDraftChunkRequest - 168, // 220: openshell.v1.OpenShell.RejectDraftChunk:input_type -> openshell.v1.RejectDraftChunkRequest - 171, // 221: openshell.v1.OpenShell.ApproveAllDraftChunks:input_type -> openshell.v1.ApproveAllDraftChunksRequest - 173, // 222: openshell.v1.OpenShell.EditDraftChunk:input_type -> openshell.v1.EditDraftChunkRequest - 175, // 223: openshell.v1.OpenShell.UndoDraftChunk:input_type -> openshell.v1.UndoDraftChunkRequest - 177, // 224: openshell.v1.OpenShell.ClearDraftChunks:input_type -> openshell.v1.ClearDraftChunksRequest - 179, // 225: openshell.v1.OpenShell.GetDraftHistory:input_type -> openshell.v1.GetDraftHistoryRequest - 8, // 226: openshell.v1.OpenShell.IssueSandboxToken:input_type -> openshell.v1.IssueSandboxTokenRequest - 10, // 227: openshell.v1.OpenShell.RefreshSandboxToken:input_type -> openshell.v1.RefreshSandboxTokenRequest - 186, // 228: openshell.v1.OpenShell.CreateWorkspace:input_type -> openshell.v1.CreateWorkspaceRequest - 188, // 229: openshell.v1.OpenShell.GetWorkspace:input_type -> openshell.v1.GetWorkspaceRequest - 190, // 230: openshell.v1.OpenShell.ListWorkspaces:input_type -> openshell.v1.ListWorkspacesRequest - 192, // 231: openshell.v1.OpenShell.DeleteWorkspace:input_type -> openshell.v1.DeleteWorkspaceRequest - 195, // 232: openshell.v1.OpenShell.AddWorkspaceMember:input_type -> openshell.v1.AddWorkspaceMemberRequest - 197, // 233: openshell.v1.OpenShell.RemoveWorkspaceMember:input_type -> openshell.v1.RemoveWorkspaceMemberRequest - 199, // 234: openshell.v1.OpenShell.ListWorkspaceMembers:input_type -> openshell.v1.ListWorkspaceMembersRequest - 13, // 235: openshell.v1.OpenShell.Health:output_type -> openshell.v1.HealthResponse - 15, // 236: openshell.v1.OpenShell.GetCurrentUser:output_type -> openshell.v1.GetCurrentUserResponse - 17, // 237: openshell.v1.OpenShell.GetGatewayInfo:output_type -> openshell.v1.GetGatewayInfoResponse - 37, // 238: openshell.v1.OpenShell.CreateSandbox:output_type -> openshell.v1.SandboxResponse - 37, // 239: openshell.v1.OpenShell.GetSandbox:output_type -> openshell.v1.SandboxResponse - 38, // 240: openshell.v1.OpenShell.ListSandboxes:output_type -> openshell.v1.ListSandboxesResponse - 39, // 241: openshell.v1.OpenShell.ListSandboxProviders:output_type -> openshell.v1.ListSandboxProvidersResponse - 40, // 242: openshell.v1.OpenShell.AttachSandboxProvider:output_type -> openshell.v1.AttachSandboxProviderResponse - 41, // 243: openshell.v1.OpenShell.DetachSandboxProvider:output_type -> openshell.v1.DetachSandboxProviderResponse - 42, // 244: openshell.v1.OpenShell.DeleteSandbox:output_type -> openshell.v1.DeleteSandboxResponse - 37, // 245: openshell.v1.OpenShell.StopSandbox:output_type -> openshell.v1.SandboxResponse - 37, // 246: openshell.v1.OpenShell.StartSandbox:output_type -> openshell.v1.SandboxResponse - 44, // 247: openshell.v1.OpenShell.CreateSshSession:output_type -> openshell.v1.CreateSshSessionResponse - 52, // 248: openshell.v1.OpenShell.ExposeService:output_type -> openshell.v1.ServiceEndpointResponse - 52, // 249: openshell.v1.OpenShell.GetService:output_type -> openshell.v1.ServiceEndpointResponse - 48, // 250: openshell.v1.OpenShell.ListServices:output_type -> openshell.v1.ListServicesResponse - 50, // 251: openshell.v1.OpenShell.DeleteService:output_type -> openshell.v1.DeleteServiceResponse - 54, // 252: openshell.v1.OpenShell.RevokeSshSession:output_type -> openshell.v1.RevokeSshSessionResponse - 59, // 253: openshell.v1.OpenShell.ExecSandbox:output_type -> openshell.v1.ExecSandboxEvent - 61, // 254: openshell.v1.OpenShell.ForwardTcp:output_type -> openshell.v1.TcpForwardFrame - 59, // 255: openshell.v1.OpenShell.ExecSandboxInteractive:output_type -> openshell.v1.ExecSandboxEvent - 74, // 256: openshell.v1.OpenShell.CreateProvider:output_type -> openshell.v1.ProviderResponse - 74, // 257: openshell.v1.OpenShell.GetProvider:output_type -> openshell.v1.ProviderResponse - 75, // 258: openshell.v1.OpenShell.ListProviders:output_type -> openshell.v1.ListProvidersResponse - 102, // 259: openshell.v1.OpenShell.ListProviderProfiles:output_type -> openshell.v1.ListProviderProfilesResponse - 101, // 260: openshell.v1.OpenShell.GetProviderProfile:output_type -> openshell.v1.ProviderProfileResponse - 104, // 261: openshell.v1.OpenShell.ImportProviderProfiles:output_type -> openshell.v1.ImportProviderProfilesResponse - 106, // 262: openshell.v1.OpenShell.UpdateProviderProfiles:output_type -> openshell.v1.UpdateProviderProfilesResponse - 108, // 263: openshell.v1.OpenShell.LintProviderProfiles:output_type -> openshell.v1.LintProviderProfilesResponse - 74, // 264: openshell.v1.OpenShell.UpdateProvider:output_type -> openshell.v1.ProviderResponse - 92, // 265: openshell.v1.OpenShell.GetProviderRefreshStatus:output_type -> openshell.v1.GetProviderRefreshStatusResponse - 94, // 266: openshell.v1.OpenShell.ConfigureProviderRefresh:output_type -> openshell.v1.ConfigureProviderRefreshResponse - 96, // 267: openshell.v1.OpenShell.RotateProviderCredential:output_type -> openshell.v1.RotateProviderCredentialResponse - 98, // 268: openshell.v1.OpenShell.DeleteProviderRefresh:output_type -> openshell.v1.DeleteProviderRefreshResponse - 109, // 269: openshell.v1.OpenShell.DeleteProvider:output_type -> openshell.v1.DeleteProviderResponse - 111, // 270: openshell.v1.OpenShell.DeleteProviderProfile:output_type -> openshell.v1.DeleteProviderProfileResponse - 241, // 271: openshell.v1.OpenShell.GetSandboxConfig:output_type -> openshell.sandbox.v1.GetSandboxConfigResponse - 242, // 272: openshell.v1.OpenShell.GetGatewayConfig:output_type -> openshell.sandbox.v1.GetGatewayConfigResponse - 126, // 273: openshell.v1.OpenShell.UpdateConfig:output_type -> openshell.v1.UpdateConfigResponse - 128, // 274: openshell.v1.OpenShell.GetSandboxPolicyStatus:output_type -> openshell.v1.GetSandboxPolicyStatusResponse - 130, // 275: openshell.v1.OpenShell.ListSandboxPolicies:output_type -> openshell.v1.ListSandboxPoliciesResponse - 132, // 276: openshell.v1.OpenShell.ReportPolicyStatus:output_type -> openshell.v1.ReportPolicyStatusResponse - 115, // 277: openshell.v1.OpenShell.GetSandboxProviderEnvironment:output_type -> openshell.v1.GetSandboxProviderEnvironmentResponse - 117, // 278: openshell.v1.OpenShell.ExchangeProviderSubjectToken:output_type -> openshell.v1.ExchangeProviderSubjectTokenResponse - 137, // 279: openshell.v1.OpenShell.GetSandboxLogs:output_type -> openshell.v1.GetSandboxLogsResponse - 136, // 280: openshell.v1.OpenShell.PushSandboxLogs:output_type -> openshell.v1.PushSandboxLogsResponse - 139, // 281: openshell.v1.OpenShell.ConnectSupervisor:output_type -> openshell.v1.GatewayMessage - 146, // 282: openshell.v1.OpenShell.ReportMainProcessExit:output_type -> openshell.v1.ReportMainProcessExitResponse - 148, // 283: openshell.v1.OpenShell.FinalizeMainProcessExit:output_type -> openshell.v1.FinalizeMainProcessExitResponse - 153, // 284: openshell.v1.OpenShell.RelayStream:output_type -> openshell.v1.RelayFrame - 66, // 285: openshell.v1.OpenShell.WatchSandbox:output_type -> openshell.v1.SandboxStreamEvent - 163, // 286: openshell.v1.OpenShell.SubmitPolicyAnalysis:output_type -> openshell.v1.SubmitPolicyAnalysisResponse - 165, // 287: openshell.v1.OpenShell.GetDraftPolicy:output_type -> openshell.v1.GetDraftPolicyResponse - 167, // 288: openshell.v1.OpenShell.ApproveDraftChunk:output_type -> openshell.v1.ApproveDraftChunkResponse - 169, // 289: openshell.v1.OpenShell.RejectDraftChunk:output_type -> openshell.v1.RejectDraftChunkResponse - 172, // 290: openshell.v1.OpenShell.ApproveAllDraftChunks:output_type -> openshell.v1.ApproveAllDraftChunksResponse - 174, // 291: openshell.v1.OpenShell.EditDraftChunk:output_type -> openshell.v1.EditDraftChunkResponse - 176, // 292: openshell.v1.OpenShell.UndoDraftChunk:output_type -> openshell.v1.UndoDraftChunkResponse - 178, // 293: openshell.v1.OpenShell.ClearDraftChunks:output_type -> openshell.v1.ClearDraftChunksResponse - 181, // 294: openshell.v1.OpenShell.GetDraftHistory:output_type -> openshell.v1.GetDraftHistoryResponse - 9, // 295: openshell.v1.OpenShell.IssueSandboxToken:output_type -> openshell.v1.IssueSandboxTokenResponse - 11, // 296: openshell.v1.OpenShell.RefreshSandboxToken:output_type -> openshell.v1.RefreshSandboxTokenResponse - 187, // 297: openshell.v1.OpenShell.CreateWorkspace:output_type -> openshell.v1.CreateWorkspaceResponse - 189, // 298: openshell.v1.OpenShell.GetWorkspace:output_type -> openshell.v1.GetWorkspaceResponse - 191, // 299: openshell.v1.OpenShell.ListWorkspaces:output_type -> openshell.v1.ListWorkspacesResponse - 193, // 300: openshell.v1.OpenShell.DeleteWorkspace:output_type -> openshell.v1.DeleteWorkspaceResponse - 196, // 301: openshell.v1.OpenShell.AddWorkspaceMember:output_type -> openshell.v1.AddWorkspaceMemberResponse - 198, // 302: openshell.v1.OpenShell.RemoveWorkspaceMember:output_type -> openshell.v1.RemoveWorkspaceMemberResponse - 200, // 303: openshell.v1.OpenShell.ListWorkspaceMembers:output_type -> openshell.v1.ListWorkspaceMembersResponse - 235, // [235:304] is the sub-list for method output_type - 166, // [166:235] is the sub-list for method input_type - 166, // [166:166] is the sub-list for extension type_name - 166, // [166:166] is the sub-list for extension extendee - 0, // [0:166] is the sub-list for field type_name + 246, // 5: openshell.v1.Sandbox.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 23, // 6: openshell.v1.Sandbox.spec:type_name -> openshell.v1.SandboxSpec + 27, // 7: openshell.v1.Sandbox.status:type_name -> openshell.v1.SandboxStatus + 246, // 8: openshell.v1.SandboxDelegatedIdentityRecord.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 21, // 9: openshell.v1.SandboxDelegatedIdentityRecord.delegated_identity:type_name -> openshell.v1.SandboxDelegatedIdentity + 221, // 10: openshell.v1.SandboxSpec.environment:type_name -> openshell.v1.SandboxSpec.EnvironmentEntry + 26, // 11: openshell.v1.SandboxSpec.template:type_name -> openshell.v1.SandboxTemplate + 247, // 12: openshell.v1.SandboxSpec.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 24, // 13: openshell.v1.SandboxSpec.resource_requirements:type_name -> openshell.v1.ResourceRequirements + 25, // 14: openshell.v1.ResourceRequirements.gpu:type_name -> openshell.v1.GpuResourceRequirements + 222, // 15: openshell.v1.SandboxTemplate.labels:type_name -> openshell.v1.SandboxTemplate.LabelsEntry + 223, // 16: openshell.v1.SandboxTemplate.annotations:type_name -> openshell.v1.SandboxTemplate.AnnotationsEntry + 224, // 17: openshell.v1.SandboxTemplate.environment:type_name -> openshell.v1.SandboxTemplate.EnvironmentEntry + 248, // 18: openshell.v1.SandboxTemplate.resources:type_name -> google.protobuf.Struct + 248, // 19: openshell.v1.SandboxTemplate.driver_config:type_name -> google.protobuf.Struct + 28, // 20: openshell.v1.SandboxStatus.conditions:type_name -> openshell.v1.SandboxCondition + 0, // 21: openshell.v1.SandboxStatus.phase:type_name -> openshell.v1.SandboxPhase + 225, // 22: openshell.v1.PlatformEvent.metadata:type_name -> openshell.v1.PlatformEvent.MetadataEntry + 23, // 23: openshell.v1.CreateSandboxRequest.spec:type_name -> openshell.v1.SandboxSpec + 226, // 24: openshell.v1.CreateSandboxRequest.labels:type_name -> openshell.v1.CreateSandboxRequest.LabelsEntry + 227, // 25: openshell.v1.CreateSandboxRequest.annotations:type_name -> openshell.v1.CreateSandboxRequest.AnnotationsEntry + 31, // 26: openshell.v1.CreateSandboxRequest.delegated_identity:type_name -> openshell.v1.DelegatedIdentityRequest + 21, // 27: openshell.v1.GetSandboxDelegatedIdentityStatusResponse.delegated_identity:type_name -> openshell.v1.SandboxDelegatedIdentity + 20, // 28: openshell.v1.WithdrawSandboxDelegatedIdentityResponse.sandbox:type_name -> openshell.v1.Sandbox + 31, // 29: openshell.v1.ExtendSandboxDelegatedIdentityRequest.delegated_identity:type_name -> openshell.v1.DelegatedIdentityRequest + 20, // 30: openshell.v1.ExtendSandboxDelegatedIdentityResponse.sandbox:type_name -> openshell.v1.Sandbox + 20, // 31: openshell.v1.SandboxResponse.sandbox:type_name -> openshell.v1.Sandbox + 20, // 32: openshell.v1.ListSandboxesResponse.sandboxes:type_name -> openshell.v1.Sandbox + 249, // 33: openshell.v1.ListSandboxProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider + 20, // 34: openshell.v1.AttachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox + 20, // 35: openshell.v1.DetachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox + 61, // 36: openshell.v1.ListServicesResponse.services:type_name -> openshell.v1.ServiceEndpointResponse + 246, // 37: openshell.v1.ServiceEndpoint.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 60, // 38: openshell.v1.ServiceEndpointResponse.endpoint:type_name -> openshell.v1.ServiceEndpoint + 228, // 39: openshell.v1.ExecSandboxRequest.environment:type_name -> openshell.v1.ExecSandboxRequest.EnvironmentEntry + 65, // 40: openshell.v1.ExecSandboxEvent.stdout:type_name -> openshell.v1.ExecSandboxStdout + 66, // 41: openshell.v1.ExecSandboxEvent.stderr:type_name -> openshell.v1.ExecSandboxStderr + 67, // 42: openshell.v1.ExecSandboxEvent.exit:type_name -> openshell.v1.ExecSandboxExit + 169, // 43: openshell.v1.TcpForwardInit.ssh:type_name -> openshell.v1.SshRelayTarget + 170, // 44: openshell.v1.TcpForwardInit.tcp:type_name -> openshell.v1.TcpRelayTarget + 69, // 45: openshell.v1.TcpForwardFrame.init:type_name -> openshell.v1.TcpForwardInit + 64, // 46: openshell.v1.ExecSandboxInput.start:type_name -> openshell.v1.ExecSandboxRequest + 72, // 47: openshell.v1.ExecSandboxInput.resize:type_name -> openshell.v1.ExecSandboxWindowResize + 246, // 48: openshell.v1.SshSession.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 20, // 49: openshell.v1.SandboxStreamEvent.sandbox:type_name -> openshell.v1.Sandbox + 76, // 50: openshell.v1.SandboxStreamEvent.log:type_name -> openshell.v1.SandboxLogLine + 29, // 51: openshell.v1.SandboxStreamEvent.event:type_name -> openshell.v1.PlatformEvent + 77, // 52: openshell.v1.SandboxStreamEvent.warning:type_name -> openshell.v1.SandboxStreamWarning + 180, // 53: openshell.v1.SandboxStreamEvent.draft_policy_update:type_name -> openshell.v1.DraftPolicyUpdate + 229, // 54: openshell.v1.SandboxLogLine.fields:type_name -> openshell.v1.SandboxLogLine.FieldsEntry + 249, // 55: openshell.v1.CreateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider + 249, // 56: openshell.v1.UpdateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider + 230, // 57: openshell.v1.UpdateProviderRequest.credential_expires_at_ms:type_name -> openshell.v1.UpdateProviderRequest.CredentialExpiresAtMsEntry + 249, // 58: openshell.v1.ProviderResponse.provider:type_name -> openshell.datamodel.v1.Provider + 249, // 59: openshell.v1.ListProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider + 118, // 60: openshell.v1.ProviderProfileImportItem.profile:type_name -> openshell.v1.ProviderProfile + 89, // 61: openshell.v1.ProviderCredentialTokenGrant.audience_overrides:type_name -> openshell.v1.ProviderCredentialTokenGrantAudienceOverride + 1, // 62: openshell.v1.ProviderCredentialTokenGrant.grant_type:type_name -> openshell.v1.ProviderCredentialTokenGrantType + 90, // 63: openshell.v1.ProviderCredentialTokenGrant.subject_token:type_name -> openshell.v1.ProviderCredentialTokenGrantSubjectToken + 95, // 64: openshell.v1.ProviderProfileCredential.refresh:type_name -> openshell.v1.ProviderCredentialRefresh + 91, // 65: openshell.v1.ProviderProfileCredential.token_grant:type_name -> openshell.v1.ProviderCredentialTokenGrant + 2, // 66: openshell.v1.ProviderCredentialRefresh.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 93, // 67: openshell.v1.ProviderCredentialRefresh.material:type_name -> openshell.v1.ProviderCredentialRefreshMaterial + 94, // 68: openshell.v1.ProviderCredentialRefresh.additional_outputs:type_name -> openshell.v1.ProviderCredentialRefreshOutput + 2, // 69: openshell.v1.ProviderCredentialRefreshStatus.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 7, // 70: openshell.v1.ProviderCredentialRefreshStatus.recovery_action:type_name -> openshell.v1.ProviderCredentialRefreshRecoveryAction + 246, // 71: openshell.v1.StoredProviderCredentialRefreshState.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 2, // 72: openshell.v1.StoredProviderCredentialRefreshState.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 231, // 73: openshell.v1.StoredProviderCredentialRefreshState.material:type_name -> openshell.v1.StoredProviderCredentialRefreshState.MaterialEntry + 232, // 74: openshell.v1.StoredProviderCredentialRefreshState.additional_output_keys:type_name -> openshell.v1.StoredProviderCredentialRefreshState.AdditionalOutputKeysEntry + 233, // 75: openshell.v1.StoredProviderCredentialRefreshState.secret_material_handles:type_name -> openshell.v1.StoredProviderCredentialRefreshState.SecretMaterialHandlesEntry + 99, // 76: openshell.v1.StoredProviderCredentialRefreshState.pending_secret_deletions:type_name -> openshell.v1.StoredRefreshMaterialDeletion + 7, // 77: openshell.v1.StoredProviderCredentialRefreshState.recovery_action:type_name -> openshell.v1.ProviderCredentialRefreshRecoveryAction + 250, // 78: openshell.v1.StoredRefreshMaterialDeletion.handle:type_name -> openshell.datamodel.v1.CredentialHandle + 246, // 79: openshell.v1.DelegatedIdentityCredential.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 246, // 80: openshell.v1.DelegatedIdentityCredentialSummary.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 101, // 81: openshell.v1.ListDelegatedIdentityCredentialsResponse.credentials:type_name -> openshell.v1.DelegatedIdentityCredentialSummary + 101, // 82: openshell.v1.GetDelegatedIdentityCredentialStatusResponse.credential:type_name -> openshell.v1.DelegatedIdentityCredentialSummary + 96, // 83: openshell.v1.GetProviderRefreshStatusResponse.credentials:type_name -> openshell.v1.ProviderCredentialRefreshStatus + 2, // 84: openshell.v1.ConfigureProviderRefreshRequest.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 234, // 85: openshell.v1.ConfigureProviderRefreshRequest.material:type_name -> openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry + 96, // 86: openshell.v1.ConfigureProviderRefreshResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus + 96, // 87: openshell.v1.RotateProviderCredentialResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus + 3, // 88: openshell.v1.ProviderProfile.category:type_name -> openshell.v1.ProviderProfileCategory + 92, // 89: openshell.v1.ProviderProfile.credentials:type_name -> openshell.v1.ProviderProfileCredential + 251, // 90: openshell.v1.ProviderProfile.endpoints:type_name -> openshell.sandbox.v1.NetworkEndpoint + 252, // 91: openshell.v1.ProviderProfile.binaries:type_name -> openshell.sandbox.v1.NetworkBinary + 97, // 92: openshell.v1.ProviderProfile.discovery:type_name -> openshell.v1.ProviderProfileDiscovery + 235, // 93: openshell.v1.ProviderProfile.annotations:type_name -> openshell.v1.ProviderProfile.AnnotationsEntry + 246, // 94: openshell.v1.StoredProviderProfile.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 118, // 95: openshell.v1.StoredProviderProfile.profile:type_name -> openshell.v1.ProviderProfile + 118, // 96: openshell.v1.ProviderProfileResponse.profile:type_name -> openshell.v1.ProviderProfile + 118, // 97: openshell.v1.ListProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile + 87, // 98: openshell.v1.ImportProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem + 88, // 99: openshell.v1.ImportProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic + 118, // 100: openshell.v1.ImportProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile + 87, // 101: openshell.v1.UpdateProviderProfilesRequest.profile:type_name -> openshell.v1.ProviderProfileImportItem + 88, // 102: openshell.v1.UpdateProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic + 118, // 103: openshell.v1.UpdateProviderProfilesResponse.profile:type_name -> openshell.v1.ProviderProfile + 87, // 104: openshell.v1.LintProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem + 88, // 105: openshell.v1.LintProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic + 132, // 106: openshell.v1.StaticCredentialBinding.endpoints:type_name -> openshell.v1.StaticCredentialEndpointBinding + 236, // 107: openshell.v1.GetSandboxProviderEnvironmentResponse.environment:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry + 237, // 108: openshell.v1.GetSandboxProviderEnvironmentResponse.credential_expires_at_ms:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpiresAtMsEntry + 238, // 109: openshell.v1.GetSandboxProviderEnvironmentResponse.dynamic_credentials:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry + 239, // 110: openshell.v1.GetSandboxProviderEnvironmentResponse.static_credential_bindings:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry + 247, // 111: openshell.v1.UpdateConfigRequest.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 253, // 112: openshell.v1.UpdateConfigRequest.setting_value:type_name -> openshell.sandbox.v1.SettingValue + 138, // 113: openshell.v1.UpdateConfigRequest.merge_operations:type_name -> openshell.v1.PolicyMergeOperation + 240, // 114: openshell.v1.UpdateConfigRequest.annotations:type_name -> openshell.v1.UpdateConfigRequest.AnnotationsEntry + 139, // 115: openshell.v1.PolicyMergeOperation.add_rule:type_name -> openshell.v1.AddNetworkRule + 140, // 116: openshell.v1.PolicyMergeOperation.remove_endpoint:type_name -> openshell.v1.RemoveNetworkEndpoint + 141, // 117: openshell.v1.PolicyMergeOperation.remove_rule:type_name -> openshell.v1.RemoveNetworkRule + 142, // 118: openshell.v1.PolicyMergeOperation.add_deny_rules:type_name -> openshell.v1.AddDenyRules + 143, // 119: openshell.v1.PolicyMergeOperation.add_allow_rules:type_name -> openshell.v1.AddAllowRules + 144, // 120: openshell.v1.PolicyMergeOperation.remove_binary:type_name -> openshell.v1.RemoveNetworkBinary + 254, // 121: openshell.v1.AddNetworkRule.rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 255, // 122: openshell.v1.AddDenyRules.deny_rules:type_name -> openshell.sandbox.v1.L7DenyRule + 256, // 123: openshell.v1.AddAllowRules.rules:type_name -> openshell.sandbox.v1.L7Rule + 241, // 124: openshell.v1.UpdateConfigResponse.annotations:type_name -> openshell.v1.UpdateConfigResponse.AnnotationsEntry + 152, // 125: openshell.v1.GetSandboxPolicyStatusResponse.revision:type_name -> openshell.v1.SandboxPolicyRevision + 152, // 126: openshell.v1.ListSandboxPoliciesResponse.revisions:type_name -> openshell.v1.SandboxPolicyRevision + 4, // 127: openshell.v1.ReportPolicyStatusRequest.status:type_name -> openshell.v1.PolicyStatus + 4, // 128: openshell.v1.SandboxPolicyRevision.status:type_name -> openshell.v1.PolicyStatus + 247, // 129: openshell.v1.SandboxPolicyRevision.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 242, // 130: openshell.v1.SandboxPolicyRevision.provenance:type_name -> openshell.v1.SandboxPolicyRevision.ProvenanceEntry + 76, // 131: openshell.v1.PushSandboxLogsRequest.logs:type_name -> openshell.v1.SandboxLogLine + 76, // 132: openshell.v1.GetSandboxLogsResponse.logs:type_name -> openshell.v1.SandboxLogLine + 159, // 133: openshell.v1.SupervisorMessage.hello:type_name -> openshell.v1.SupervisorHello + 162, // 134: openshell.v1.SupervisorMessage.heartbeat:type_name -> openshell.v1.SupervisorHeartbeat + 173, // 135: openshell.v1.SupervisorMessage.relay_open_result:type_name -> openshell.v1.RelayOpenResult + 174, // 136: openshell.v1.SupervisorMessage.relay_close:type_name -> openshell.v1.RelayClose + 160, // 137: openshell.v1.GatewayMessage.session_accepted:type_name -> openshell.v1.SessionAccepted + 161, // 138: openshell.v1.GatewayMessage.session_rejected:type_name -> openshell.v1.SessionRejected + 163, // 139: openshell.v1.GatewayMessage.heartbeat:type_name -> openshell.v1.GatewayHeartbeat + 168, // 140: openshell.v1.GatewayMessage.relay_open:type_name -> openshell.v1.RelayOpen + 174, // 141: openshell.v1.GatewayMessage.relay_close:type_name -> openshell.v1.RelayClose + 169, // 142: openshell.v1.RelayOpen.ssh:type_name -> openshell.v1.SshRelayTarget + 170, // 143: openshell.v1.RelayOpen.tcp:type_name -> openshell.v1.TcpRelayTarget + 171, // 144: openshell.v1.RelayFrame.init:type_name -> openshell.v1.RelayInit + 175, // 145: openshell.v1.DenialSummary.l7_request_samples:type_name -> openshell.v1.L7RequestSample + 177, // 146: openshell.v1.NetworkActivitySummary.denials_by_group:type_name -> openshell.v1.DenialGroupCount + 254, // 147: openshell.v1.PolicyChunk.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 247, // 148: openshell.v1.PolicyChunk.current_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 247, // 149: openshell.v1.PolicyChunk.candidate_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 176, // 150: openshell.v1.SubmitPolicyAnalysisRequest.summaries:type_name -> openshell.v1.DenialSummary + 179, // 151: openshell.v1.SubmitPolicyAnalysisRequest.proposed_chunks:type_name -> openshell.v1.PolicyChunk + 178, // 152: openshell.v1.SubmitPolicyAnalysisRequest.network_activity_summaries:type_name -> openshell.v1.NetworkActivitySummary + 179, // 153: openshell.v1.GetDraftPolicyResponse.chunks:type_name -> openshell.v1.PolicyChunk + 189, // 154: openshell.v1.ApproveAllDraftChunksRequest.approvals:type_name -> openshell.v1.DraftChunkApproval + 254, // 155: openshell.v1.EditDraftChunkRequest.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 199, // 156: openshell.v1.GetDraftHistoryResponse.entries:type_name -> openshell.v1.DraftHistoryEntry + 247, // 157: openshell.v1.PolicyRevisionPayload.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 243, // 158: openshell.v1.PolicyRevisionPayload.provenance:type_name -> openshell.v1.PolicyRevisionPayload.ProvenanceEntry + 254, // 159: openshell.v1.DraftChunkPayload.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 247, // 160: openshell.v1.DraftChunkPayload.current_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 247, // 161: openshell.v1.DraftChunkPayload.candidate_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 244, // 162: openshell.v1.StoredPolicyRevision.provenance:type_name -> openshell.v1.StoredPolicyRevision.ProvenanceEntry + 247, // 163: openshell.v1.StoredDraftChunk.current_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 247, // 164: openshell.v1.StoredDraftChunk.candidate_effective_policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 245, // 165: openshell.v1.CreateWorkspaceRequest.labels:type_name -> openshell.v1.CreateWorkspaceRequest.LabelsEntry + 257, // 166: openshell.v1.CreateWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace + 257, // 167: openshell.v1.GetWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace + 257, // 168: openshell.v1.ListWorkspacesResponse.workspaces:type_name -> openshell.datamodel.v1.Workspace + 246, // 169: openshell.v1.WorkspaceMember.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 6, // 170: openshell.v1.WorkspaceMember.role:type_name -> openshell.v1.WorkspaceRole + 6, // 171: openshell.v1.AddWorkspaceMemberRequest.role:type_name -> openshell.v1.WorkspaceRole + 213, // 172: openshell.v1.AddWorkspaceMemberResponse.member:type_name -> openshell.v1.WorkspaceMember + 213, // 173: openshell.v1.ListWorkspaceMembersResponse.members:type_name -> openshell.v1.WorkspaceMember + 250, // 174: openshell.v1.StoredProviderCredentialRefreshState.SecretMaterialHandlesEntry.value:type_name -> openshell.datamodel.v1.CredentialHandle + 92, // 175: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry.value:type_name -> openshell.v1.ProviderProfileCredential + 133, // 176: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry.value:type_name -> openshell.v1.StaticCredentialBinding + 12, // 177: openshell.v1.OpenShell.Health:input_type -> openshell.v1.HealthRequest + 14, // 178: openshell.v1.OpenShell.GetCurrentUser:input_type -> openshell.v1.GetCurrentUserRequest + 16, // 179: openshell.v1.OpenShell.GetGatewayInfo:input_type -> openshell.v1.GetGatewayInfoRequest + 30, // 180: openshell.v1.OpenShell.CreateSandbox:input_type -> openshell.v1.CreateSandboxRequest + 32, // 181: openshell.v1.OpenShell.GetSandboxDelegatedIdentityStatus:input_type -> openshell.v1.GetSandboxDelegatedIdentityStatusRequest + 34, // 182: openshell.v1.OpenShell.WithdrawSandboxDelegatedIdentity:input_type -> openshell.v1.WithdrawSandboxDelegatedIdentityRequest + 36, // 183: openshell.v1.OpenShell.ExtendSandboxDelegatedIdentity:input_type -> openshell.v1.ExtendSandboxDelegatedIdentityRequest + 38, // 184: openshell.v1.OpenShell.GetSandbox:input_type -> openshell.v1.GetSandboxRequest + 39, // 185: openshell.v1.OpenShell.ListSandboxes:input_type -> openshell.v1.ListSandboxesRequest + 40, // 186: openshell.v1.OpenShell.ListSandboxProviders:input_type -> openshell.v1.ListSandboxProvidersRequest + 41, // 187: openshell.v1.OpenShell.AttachSandboxProvider:input_type -> openshell.v1.AttachSandboxProviderRequest + 42, // 188: openshell.v1.OpenShell.DetachSandboxProvider:input_type -> openshell.v1.DetachSandboxProviderRequest + 43, // 189: openshell.v1.OpenShell.DeleteSandbox:input_type -> openshell.v1.DeleteSandboxRequest + 44, // 190: openshell.v1.OpenShell.StopSandbox:input_type -> openshell.v1.StopSandboxRequest + 45, // 191: openshell.v1.OpenShell.StartSandbox:input_type -> openshell.v1.StartSandboxRequest + 52, // 192: openshell.v1.OpenShell.CreateSshSession:input_type -> openshell.v1.CreateSshSessionRequest + 54, // 193: openshell.v1.OpenShell.ExposeService:input_type -> openshell.v1.ExposeServiceRequest + 55, // 194: openshell.v1.OpenShell.GetService:input_type -> openshell.v1.GetServiceRequest + 56, // 195: openshell.v1.OpenShell.ListServices:input_type -> openshell.v1.ListServicesRequest + 58, // 196: openshell.v1.OpenShell.DeleteService:input_type -> openshell.v1.DeleteServiceRequest + 62, // 197: openshell.v1.OpenShell.RevokeSshSession:input_type -> openshell.v1.RevokeSshSessionRequest + 64, // 198: openshell.v1.OpenShell.ExecSandbox:input_type -> openshell.v1.ExecSandboxRequest + 70, // 199: openshell.v1.OpenShell.ForwardTcp:input_type -> openshell.v1.TcpForwardFrame + 71, // 200: openshell.v1.OpenShell.ExecSandboxInteractive:input_type -> openshell.v1.ExecSandboxInput + 78, // 201: openshell.v1.OpenShell.CreateProvider:input_type -> openshell.v1.CreateProviderRequest + 79, // 202: openshell.v1.OpenShell.GetProvider:input_type -> openshell.v1.GetProviderRequest + 80, // 203: openshell.v1.OpenShell.ListProviders:input_type -> openshell.v1.ListProvidersRequest + 85, // 204: openshell.v1.OpenShell.ListProviderProfiles:input_type -> openshell.v1.ListProviderProfilesRequest + 86, // 205: openshell.v1.OpenShell.GetProviderProfile:input_type -> openshell.v1.GetProviderProfileRequest + 122, // 206: openshell.v1.OpenShell.ImportProviderProfiles:input_type -> openshell.v1.ImportProviderProfilesRequest + 124, // 207: openshell.v1.OpenShell.UpdateProviderProfiles:input_type -> openshell.v1.UpdateProviderProfilesRequest + 126, // 208: openshell.v1.OpenShell.LintProviderProfiles:input_type -> openshell.v1.LintProviderProfilesRequest + 81, // 209: openshell.v1.OpenShell.UpdateProvider:input_type -> openshell.v1.UpdateProviderRequest + 110, // 210: openshell.v1.OpenShell.GetProviderRefreshStatus:input_type -> openshell.v1.GetProviderRefreshStatusRequest + 112, // 211: openshell.v1.OpenShell.ConfigureProviderRefresh:input_type -> openshell.v1.ConfigureProviderRefreshRequest + 114, // 212: openshell.v1.OpenShell.RotateProviderCredential:input_type -> openshell.v1.RotateProviderCredentialRequest + 102, // 213: openshell.v1.OpenShell.ListDelegatedIdentityCredentials:input_type -> openshell.v1.ListDelegatedIdentityCredentialsRequest + 104, // 214: openshell.v1.OpenShell.GetDelegatedIdentityCredentialStatus:input_type -> openshell.v1.GetDelegatedIdentityCredentialStatusRequest + 106, // 215: openshell.v1.OpenShell.RevokeDelegatedIdentityCredential:input_type -> openshell.v1.RevokeDelegatedIdentityCredentialRequest + 108, // 216: openshell.v1.OpenShell.DeleteDelegatedIdentityCredential:input_type -> openshell.v1.DeleteDelegatedIdentityCredentialRequest + 116, // 217: openshell.v1.OpenShell.DeleteProviderRefresh:input_type -> openshell.v1.DeleteProviderRefreshRequest + 82, // 218: openshell.v1.OpenShell.DeleteProvider:input_type -> openshell.v1.DeleteProviderRequest + 129, // 219: openshell.v1.OpenShell.DeleteProviderProfile:input_type -> openshell.v1.DeleteProviderProfileRequest + 258, // 220: openshell.v1.OpenShell.GetSandboxConfig:input_type -> openshell.sandbox.v1.GetSandboxConfigRequest + 259, // 221: openshell.v1.OpenShell.GetGatewayConfig:input_type -> openshell.sandbox.v1.GetGatewayConfigRequest + 137, // 222: openshell.v1.OpenShell.UpdateConfig:input_type -> openshell.v1.UpdateConfigRequest + 146, // 223: openshell.v1.OpenShell.GetSandboxPolicyStatus:input_type -> openshell.v1.GetSandboxPolicyStatusRequest + 148, // 224: openshell.v1.OpenShell.ListSandboxPolicies:input_type -> openshell.v1.ListSandboxPoliciesRequest + 150, // 225: openshell.v1.OpenShell.ReportPolicyStatus:input_type -> openshell.v1.ReportPolicyStatusRequest + 131, // 226: openshell.v1.OpenShell.GetSandboxProviderEnvironment:input_type -> openshell.v1.GetSandboxProviderEnvironmentRequest + 135, // 227: openshell.v1.OpenShell.ExchangeProviderSubjectToken:input_type -> openshell.v1.ExchangeProviderSubjectTokenRequest + 153, // 228: openshell.v1.OpenShell.GetSandboxLogs:input_type -> openshell.v1.GetSandboxLogsRequest + 154, // 229: openshell.v1.OpenShell.PushSandboxLogs:input_type -> openshell.v1.PushSandboxLogsRequest + 157, // 230: openshell.v1.OpenShell.ConnectSupervisor:input_type -> openshell.v1.SupervisorMessage + 164, // 231: openshell.v1.OpenShell.ReportMainProcessExit:input_type -> openshell.v1.ReportMainProcessExitRequest + 166, // 232: openshell.v1.OpenShell.FinalizeMainProcessExit:input_type -> openshell.v1.FinalizeMainProcessExitRequest + 172, // 233: openshell.v1.OpenShell.RelayStream:input_type -> openshell.v1.RelayFrame + 74, // 234: openshell.v1.OpenShell.WatchSandbox:input_type -> openshell.v1.WatchSandboxRequest + 181, // 235: openshell.v1.OpenShell.SubmitPolicyAnalysis:input_type -> openshell.v1.SubmitPolicyAnalysisRequest + 183, // 236: openshell.v1.OpenShell.GetDraftPolicy:input_type -> openshell.v1.GetDraftPolicyRequest + 185, // 237: openshell.v1.OpenShell.ApproveDraftChunk:input_type -> openshell.v1.ApproveDraftChunkRequest + 187, // 238: openshell.v1.OpenShell.RejectDraftChunk:input_type -> openshell.v1.RejectDraftChunkRequest + 190, // 239: openshell.v1.OpenShell.ApproveAllDraftChunks:input_type -> openshell.v1.ApproveAllDraftChunksRequest + 192, // 240: openshell.v1.OpenShell.EditDraftChunk:input_type -> openshell.v1.EditDraftChunkRequest + 194, // 241: openshell.v1.OpenShell.UndoDraftChunk:input_type -> openshell.v1.UndoDraftChunkRequest + 196, // 242: openshell.v1.OpenShell.ClearDraftChunks:input_type -> openshell.v1.ClearDraftChunksRequest + 198, // 243: openshell.v1.OpenShell.GetDraftHistory:input_type -> openshell.v1.GetDraftHistoryRequest + 8, // 244: openshell.v1.OpenShell.IssueSandboxToken:input_type -> openshell.v1.IssueSandboxTokenRequest + 10, // 245: openshell.v1.OpenShell.RefreshSandboxToken:input_type -> openshell.v1.RefreshSandboxTokenRequest + 205, // 246: openshell.v1.OpenShell.CreateWorkspace:input_type -> openshell.v1.CreateWorkspaceRequest + 207, // 247: openshell.v1.OpenShell.GetWorkspace:input_type -> openshell.v1.GetWorkspaceRequest + 209, // 248: openshell.v1.OpenShell.ListWorkspaces:input_type -> openshell.v1.ListWorkspacesRequest + 211, // 249: openshell.v1.OpenShell.DeleteWorkspace:input_type -> openshell.v1.DeleteWorkspaceRequest + 214, // 250: openshell.v1.OpenShell.AddWorkspaceMember:input_type -> openshell.v1.AddWorkspaceMemberRequest + 216, // 251: openshell.v1.OpenShell.RemoveWorkspaceMember:input_type -> openshell.v1.RemoveWorkspaceMemberRequest + 218, // 252: openshell.v1.OpenShell.ListWorkspaceMembers:input_type -> openshell.v1.ListWorkspaceMembersRequest + 13, // 253: openshell.v1.OpenShell.Health:output_type -> openshell.v1.HealthResponse + 15, // 254: openshell.v1.OpenShell.GetCurrentUser:output_type -> openshell.v1.GetCurrentUserResponse + 17, // 255: openshell.v1.OpenShell.GetGatewayInfo:output_type -> openshell.v1.GetGatewayInfoResponse + 46, // 256: openshell.v1.OpenShell.CreateSandbox:output_type -> openshell.v1.SandboxResponse + 33, // 257: openshell.v1.OpenShell.GetSandboxDelegatedIdentityStatus:output_type -> openshell.v1.GetSandboxDelegatedIdentityStatusResponse + 35, // 258: openshell.v1.OpenShell.WithdrawSandboxDelegatedIdentity:output_type -> openshell.v1.WithdrawSandboxDelegatedIdentityResponse + 37, // 259: openshell.v1.OpenShell.ExtendSandboxDelegatedIdentity:output_type -> openshell.v1.ExtendSandboxDelegatedIdentityResponse + 46, // 260: openshell.v1.OpenShell.GetSandbox:output_type -> openshell.v1.SandboxResponse + 47, // 261: openshell.v1.OpenShell.ListSandboxes:output_type -> openshell.v1.ListSandboxesResponse + 48, // 262: openshell.v1.OpenShell.ListSandboxProviders:output_type -> openshell.v1.ListSandboxProvidersResponse + 49, // 263: openshell.v1.OpenShell.AttachSandboxProvider:output_type -> openshell.v1.AttachSandboxProviderResponse + 50, // 264: openshell.v1.OpenShell.DetachSandboxProvider:output_type -> openshell.v1.DetachSandboxProviderResponse + 51, // 265: openshell.v1.OpenShell.DeleteSandbox:output_type -> openshell.v1.DeleteSandboxResponse + 46, // 266: openshell.v1.OpenShell.StopSandbox:output_type -> openshell.v1.SandboxResponse + 46, // 267: openshell.v1.OpenShell.StartSandbox:output_type -> openshell.v1.SandboxResponse + 53, // 268: openshell.v1.OpenShell.CreateSshSession:output_type -> openshell.v1.CreateSshSessionResponse + 61, // 269: openshell.v1.OpenShell.ExposeService:output_type -> openshell.v1.ServiceEndpointResponse + 61, // 270: openshell.v1.OpenShell.GetService:output_type -> openshell.v1.ServiceEndpointResponse + 57, // 271: openshell.v1.OpenShell.ListServices:output_type -> openshell.v1.ListServicesResponse + 59, // 272: openshell.v1.OpenShell.DeleteService:output_type -> openshell.v1.DeleteServiceResponse + 63, // 273: openshell.v1.OpenShell.RevokeSshSession:output_type -> openshell.v1.RevokeSshSessionResponse + 68, // 274: openshell.v1.OpenShell.ExecSandbox:output_type -> openshell.v1.ExecSandboxEvent + 70, // 275: openshell.v1.OpenShell.ForwardTcp:output_type -> openshell.v1.TcpForwardFrame + 68, // 276: openshell.v1.OpenShell.ExecSandboxInteractive:output_type -> openshell.v1.ExecSandboxEvent + 83, // 277: openshell.v1.OpenShell.CreateProvider:output_type -> openshell.v1.ProviderResponse + 83, // 278: openshell.v1.OpenShell.GetProvider:output_type -> openshell.v1.ProviderResponse + 84, // 279: openshell.v1.OpenShell.ListProviders:output_type -> openshell.v1.ListProvidersResponse + 121, // 280: openshell.v1.OpenShell.ListProviderProfiles:output_type -> openshell.v1.ListProviderProfilesResponse + 120, // 281: openshell.v1.OpenShell.GetProviderProfile:output_type -> openshell.v1.ProviderProfileResponse + 123, // 282: openshell.v1.OpenShell.ImportProviderProfiles:output_type -> openshell.v1.ImportProviderProfilesResponse + 125, // 283: openshell.v1.OpenShell.UpdateProviderProfiles:output_type -> openshell.v1.UpdateProviderProfilesResponse + 127, // 284: openshell.v1.OpenShell.LintProviderProfiles:output_type -> openshell.v1.LintProviderProfilesResponse + 83, // 285: openshell.v1.OpenShell.UpdateProvider:output_type -> openshell.v1.ProviderResponse + 111, // 286: openshell.v1.OpenShell.GetProviderRefreshStatus:output_type -> openshell.v1.GetProviderRefreshStatusResponse + 113, // 287: openshell.v1.OpenShell.ConfigureProviderRefresh:output_type -> openshell.v1.ConfigureProviderRefreshResponse + 115, // 288: openshell.v1.OpenShell.RotateProviderCredential:output_type -> openshell.v1.RotateProviderCredentialResponse + 103, // 289: openshell.v1.OpenShell.ListDelegatedIdentityCredentials:output_type -> openshell.v1.ListDelegatedIdentityCredentialsResponse + 105, // 290: openshell.v1.OpenShell.GetDelegatedIdentityCredentialStatus:output_type -> openshell.v1.GetDelegatedIdentityCredentialStatusResponse + 107, // 291: openshell.v1.OpenShell.RevokeDelegatedIdentityCredential:output_type -> openshell.v1.RevokeDelegatedIdentityCredentialResponse + 109, // 292: openshell.v1.OpenShell.DeleteDelegatedIdentityCredential:output_type -> openshell.v1.DeleteDelegatedIdentityCredentialResponse + 117, // 293: openshell.v1.OpenShell.DeleteProviderRefresh:output_type -> openshell.v1.DeleteProviderRefreshResponse + 128, // 294: openshell.v1.OpenShell.DeleteProvider:output_type -> openshell.v1.DeleteProviderResponse + 130, // 295: openshell.v1.OpenShell.DeleteProviderProfile:output_type -> openshell.v1.DeleteProviderProfileResponse + 260, // 296: openshell.v1.OpenShell.GetSandboxConfig:output_type -> openshell.sandbox.v1.GetSandboxConfigResponse + 261, // 297: openshell.v1.OpenShell.GetGatewayConfig:output_type -> openshell.sandbox.v1.GetGatewayConfigResponse + 145, // 298: openshell.v1.OpenShell.UpdateConfig:output_type -> openshell.v1.UpdateConfigResponse + 147, // 299: openshell.v1.OpenShell.GetSandboxPolicyStatus:output_type -> openshell.v1.GetSandboxPolicyStatusResponse + 149, // 300: openshell.v1.OpenShell.ListSandboxPolicies:output_type -> openshell.v1.ListSandboxPoliciesResponse + 151, // 301: openshell.v1.OpenShell.ReportPolicyStatus:output_type -> openshell.v1.ReportPolicyStatusResponse + 134, // 302: openshell.v1.OpenShell.GetSandboxProviderEnvironment:output_type -> openshell.v1.GetSandboxProviderEnvironmentResponse + 136, // 303: openshell.v1.OpenShell.ExchangeProviderSubjectToken:output_type -> openshell.v1.ExchangeProviderSubjectTokenResponse + 156, // 304: openshell.v1.OpenShell.GetSandboxLogs:output_type -> openshell.v1.GetSandboxLogsResponse + 155, // 305: openshell.v1.OpenShell.PushSandboxLogs:output_type -> openshell.v1.PushSandboxLogsResponse + 158, // 306: openshell.v1.OpenShell.ConnectSupervisor:output_type -> openshell.v1.GatewayMessage + 165, // 307: openshell.v1.OpenShell.ReportMainProcessExit:output_type -> openshell.v1.ReportMainProcessExitResponse + 167, // 308: openshell.v1.OpenShell.FinalizeMainProcessExit:output_type -> openshell.v1.FinalizeMainProcessExitResponse + 172, // 309: openshell.v1.OpenShell.RelayStream:output_type -> openshell.v1.RelayFrame + 75, // 310: openshell.v1.OpenShell.WatchSandbox:output_type -> openshell.v1.SandboxStreamEvent + 182, // 311: openshell.v1.OpenShell.SubmitPolicyAnalysis:output_type -> openshell.v1.SubmitPolicyAnalysisResponse + 184, // 312: openshell.v1.OpenShell.GetDraftPolicy:output_type -> openshell.v1.GetDraftPolicyResponse + 186, // 313: openshell.v1.OpenShell.ApproveDraftChunk:output_type -> openshell.v1.ApproveDraftChunkResponse + 188, // 314: openshell.v1.OpenShell.RejectDraftChunk:output_type -> openshell.v1.RejectDraftChunkResponse + 191, // 315: openshell.v1.OpenShell.ApproveAllDraftChunks:output_type -> openshell.v1.ApproveAllDraftChunksResponse + 193, // 316: openshell.v1.OpenShell.EditDraftChunk:output_type -> openshell.v1.EditDraftChunkResponse + 195, // 317: openshell.v1.OpenShell.UndoDraftChunk:output_type -> openshell.v1.UndoDraftChunkResponse + 197, // 318: openshell.v1.OpenShell.ClearDraftChunks:output_type -> openshell.v1.ClearDraftChunksResponse + 200, // 319: openshell.v1.OpenShell.GetDraftHistory:output_type -> openshell.v1.GetDraftHistoryResponse + 9, // 320: openshell.v1.OpenShell.IssueSandboxToken:output_type -> openshell.v1.IssueSandboxTokenResponse + 11, // 321: openshell.v1.OpenShell.RefreshSandboxToken:output_type -> openshell.v1.RefreshSandboxTokenResponse + 206, // 322: openshell.v1.OpenShell.CreateWorkspace:output_type -> openshell.v1.CreateWorkspaceResponse + 208, // 323: openshell.v1.OpenShell.GetWorkspace:output_type -> openshell.v1.GetWorkspaceResponse + 210, // 324: openshell.v1.OpenShell.ListWorkspaces:output_type -> openshell.v1.ListWorkspacesResponse + 212, // 325: openshell.v1.OpenShell.DeleteWorkspace:output_type -> openshell.v1.DeleteWorkspaceResponse + 215, // 326: openshell.v1.OpenShell.AddWorkspaceMember:output_type -> openshell.v1.AddWorkspaceMemberResponse + 217, // 327: openshell.v1.OpenShell.RemoveWorkspaceMember:output_type -> openshell.v1.RemoveWorkspaceMemberResponse + 219, // 328: openshell.v1.OpenShell.ListWorkspaceMembers:output_type -> openshell.v1.ListWorkspaceMembersResponse + 253, // [253:329] is the sub-list for method output_type + 177, // [177:253] is the sub-list for method input_type + 177, // [177:177] is the sub-list for extension type_name + 177, // [177:177] is the sub-list for extension extendee + 0, // [0:177] is the sub-list for field type_name } func init() { file_openshell_proto_init() } @@ -15916,36 +17270,36 @@ func file_openshell_proto_init() { if File_openshell_proto != nil { return } - file_openshell_proto_msgTypes[15].OneofWrappers = []any{} - file_openshell_proto_msgTypes[16].OneofWrappers = []any{} file_openshell_proto_msgTypes[17].OneofWrappers = []any{} - file_openshell_proto_msgTypes[51].OneofWrappers = []any{ + file_openshell_proto_msgTypes[18].OneofWrappers = []any{} + file_openshell_proto_msgTypes[19].OneofWrappers = []any{} + file_openshell_proto_msgTypes[60].OneofWrappers = []any{ (*ExecSandboxEvent_Stdout)(nil), (*ExecSandboxEvent_Stderr)(nil), (*ExecSandboxEvent_Exit)(nil), } - file_openshell_proto_msgTypes[52].OneofWrappers = []any{ + file_openshell_proto_msgTypes[61].OneofWrappers = []any{ (*TcpForwardInit_Ssh)(nil), (*TcpForwardInit_Tcp)(nil), } - file_openshell_proto_msgTypes[53].OneofWrappers = []any{ + file_openshell_proto_msgTypes[62].OneofWrappers = []any{ (*TcpForwardFrame_Init)(nil), (*TcpForwardFrame_Data)(nil), } - file_openshell_proto_msgTypes[54].OneofWrappers = []any{ + file_openshell_proto_msgTypes[63].OneofWrappers = []any{ (*ExecSandboxInput_Start)(nil), (*ExecSandboxInput_Stdin)(nil), (*ExecSandboxInput_Resize)(nil), } - file_openshell_proto_msgTypes[58].OneofWrappers = []any{ + file_openshell_proto_msgTypes[67].OneofWrappers = []any{ (*SandboxStreamEvent_Sandbox)(nil), (*SandboxStreamEvent_Log)(nil), (*SandboxStreamEvent_Event)(nil), (*SandboxStreamEvent_Warning)(nil), (*SandboxStreamEvent_DraftPolicyUpdate)(nil), } - file_openshell_proto_msgTypes[85].OneofWrappers = []any{} - file_openshell_proto_msgTypes[111].OneofWrappers = []any{ + file_openshell_proto_msgTypes[104].OneofWrappers = []any{} + file_openshell_proto_msgTypes[130].OneofWrappers = []any{ (*PolicyMergeOperation_AddRule)(nil), (*PolicyMergeOperation_RemoveEndpoint)(nil), (*PolicyMergeOperation_RemoveRule)(nil), @@ -15953,36 +17307,36 @@ func file_openshell_proto_init() { (*PolicyMergeOperation_AddAllowRules)(nil), (*PolicyMergeOperation_RemoveBinary)(nil), } - file_openshell_proto_msgTypes[130].OneofWrappers = []any{ + file_openshell_proto_msgTypes[149].OneofWrappers = []any{ (*SupervisorMessage_Hello)(nil), (*SupervisorMessage_Heartbeat)(nil), (*SupervisorMessage_RelayOpenResult)(nil), (*SupervisorMessage_RelayClose)(nil), } - file_openshell_proto_msgTypes[131].OneofWrappers = []any{ + file_openshell_proto_msgTypes[150].OneofWrappers = []any{ (*GatewayMessage_SessionAccepted)(nil), (*GatewayMessage_SessionRejected)(nil), (*GatewayMessage_Heartbeat)(nil), (*GatewayMessage_RelayOpen)(nil), (*GatewayMessage_RelayClose)(nil), } - file_openshell_proto_msgTypes[141].OneofWrappers = []any{ + file_openshell_proto_msgTypes[160].OneofWrappers = []any{ (*RelayOpen_Ssh)(nil), (*RelayOpen_Tcp)(nil), } - file_openshell_proto_msgTypes[145].OneofWrappers = []any{ + file_openshell_proto_msgTypes[164].OneofWrappers = []any{ (*RelayFrame_Init)(nil), (*RelayFrame_Data)(nil), } - file_openshell_proto_msgTypes[176].OneofWrappers = []any{} - file_openshell_proto_msgTypes[177].OneofWrappers = []any{} + file_openshell_proto_msgTypes[195].OneofWrappers = []any{} + file_openshell_proto_msgTypes[196].OneofWrappers = []any{} type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_openshell_proto_rawDesc), len(file_openshell_proto_rawDesc)), NumEnums: 8, - NumMessages: 219, + NumMessages: 238, NumExtensions: 0, NumServices: 1, }, diff --git a/sdk/go/proto/openshellv1/openshell_grpc.pb.go b/sdk/go/proto/openshellv1/openshell_grpc.pb.go index 0d98c66ac8..0c0da8fd01 100644 --- a/sdk/go/proto/openshellv1/openshell_grpc.pb.go +++ b/sdk/go/proto/openshellv1/openshell_grpc.pb.go @@ -23,75 +23,82 @@ import ( const _ = grpc.SupportPackageIsVersion9 const ( - OpenShell_Health_FullMethodName = "/openshell.v1.OpenShell/Health" - OpenShell_GetCurrentUser_FullMethodName = "/openshell.v1.OpenShell/GetCurrentUser" - OpenShell_GetGatewayInfo_FullMethodName = "/openshell.v1.OpenShell/GetGatewayInfo" - OpenShell_CreateSandbox_FullMethodName = "/openshell.v1.OpenShell/CreateSandbox" - OpenShell_GetSandbox_FullMethodName = "/openshell.v1.OpenShell/GetSandbox" - OpenShell_ListSandboxes_FullMethodName = "/openshell.v1.OpenShell/ListSandboxes" - OpenShell_ListSandboxProviders_FullMethodName = "/openshell.v1.OpenShell/ListSandboxProviders" - OpenShell_AttachSandboxProvider_FullMethodName = "/openshell.v1.OpenShell/AttachSandboxProvider" - OpenShell_DetachSandboxProvider_FullMethodName = "/openshell.v1.OpenShell/DetachSandboxProvider" - OpenShell_DeleteSandbox_FullMethodName = "/openshell.v1.OpenShell/DeleteSandbox" - OpenShell_StopSandbox_FullMethodName = "/openshell.v1.OpenShell/StopSandbox" - OpenShell_StartSandbox_FullMethodName = "/openshell.v1.OpenShell/StartSandbox" - OpenShell_CreateSshSession_FullMethodName = "/openshell.v1.OpenShell/CreateSshSession" - OpenShell_ExposeService_FullMethodName = "/openshell.v1.OpenShell/ExposeService" - OpenShell_GetService_FullMethodName = "/openshell.v1.OpenShell/GetService" - OpenShell_ListServices_FullMethodName = "/openshell.v1.OpenShell/ListServices" - OpenShell_DeleteService_FullMethodName = "/openshell.v1.OpenShell/DeleteService" - OpenShell_RevokeSshSession_FullMethodName = "/openshell.v1.OpenShell/RevokeSshSession" - OpenShell_ExecSandbox_FullMethodName = "/openshell.v1.OpenShell/ExecSandbox" - OpenShell_ForwardTcp_FullMethodName = "/openshell.v1.OpenShell/ForwardTcp" - OpenShell_ExecSandboxInteractive_FullMethodName = "/openshell.v1.OpenShell/ExecSandboxInteractive" - OpenShell_CreateProvider_FullMethodName = "/openshell.v1.OpenShell/CreateProvider" - OpenShell_GetProvider_FullMethodName = "/openshell.v1.OpenShell/GetProvider" - OpenShell_ListProviders_FullMethodName = "/openshell.v1.OpenShell/ListProviders" - OpenShell_ListProviderProfiles_FullMethodName = "/openshell.v1.OpenShell/ListProviderProfiles" - OpenShell_GetProviderProfile_FullMethodName = "/openshell.v1.OpenShell/GetProviderProfile" - OpenShell_ImportProviderProfiles_FullMethodName = "/openshell.v1.OpenShell/ImportProviderProfiles" - OpenShell_UpdateProviderProfiles_FullMethodName = "/openshell.v1.OpenShell/UpdateProviderProfiles" - OpenShell_LintProviderProfiles_FullMethodName = "/openshell.v1.OpenShell/LintProviderProfiles" - OpenShell_UpdateProvider_FullMethodName = "/openshell.v1.OpenShell/UpdateProvider" - OpenShell_GetProviderRefreshStatus_FullMethodName = "/openshell.v1.OpenShell/GetProviderRefreshStatus" - OpenShell_ConfigureProviderRefresh_FullMethodName = "/openshell.v1.OpenShell/ConfigureProviderRefresh" - OpenShell_RotateProviderCredential_FullMethodName = "/openshell.v1.OpenShell/RotateProviderCredential" - OpenShell_DeleteProviderRefresh_FullMethodName = "/openshell.v1.OpenShell/DeleteProviderRefresh" - OpenShell_DeleteProvider_FullMethodName = "/openshell.v1.OpenShell/DeleteProvider" - OpenShell_DeleteProviderProfile_FullMethodName = "/openshell.v1.OpenShell/DeleteProviderProfile" - OpenShell_GetSandboxConfig_FullMethodName = "/openshell.v1.OpenShell/GetSandboxConfig" - OpenShell_GetGatewayConfig_FullMethodName = "/openshell.v1.OpenShell/GetGatewayConfig" - OpenShell_UpdateConfig_FullMethodName = "/openshell.v1.OpenShell/UpdateConfig" - OpenShell_GetSandboxPolicyStatus_FullMethodName = "/openshell.v1.OpenShell/GetSandboxPolicyStatus" - OpenShell_ListSandboxPolicies_FullMethodName = "/openshell.v1.OpenShell/ListSandboxPolicies" - OpenShell_ReportPolicyStatus_FullMethodName = "/openshell.v1.OpenShell/ReportPolicyStatus" - OpenShell_GetSandboxProviderEnvironment_FullMethodName = "/openshell.v1.OpenShell/GetSandboxProviderEnvironment" - OpenShell_ExchangeProviderSubjectToken_FullMethodName = "/openshell.v1.OpenShell/ExchangeProviderSubjectToken" - OpenShell_GetSandboxLogs_FullMethodName = "/openshell.v1.OpenShell/GetSandboxLogs" - OpenShell_PushSandboxLogs_FullMethodName = "/openshell.v1.OpenShell/PushSandboxLogs" - OpenShell_ConnectSupervisor_FullMethodName = "/openshell.v1.OpenShell/ConnectSupervisor" - OpenShell_ReportMainProcessExit_FullMethodName = "/openshell.v1.OpenShell/ReportMainProcessExit" - OpenShell_FinalizeMainProcessExit_FullMethodName = "/openshell.v1.OpenShell/FinalizeMainProcessExit" - OpenShell_RelayStream_FullMethodName = "/openshell.v1.OpenShell/RelayStream" - OpenShell_WatchSandbox_FullMethodName = "/openshell.v1.OpenShell/WatchSandbox" - OpenShell_SubmitPolicyAnalysis_FullMethodName = "/openshell.v1.OpenShell/SubmitPolicyAnalysis" - OpenShell_GetDraftPolicy_FullMethodName = "/openshell.v1.OpenShell/GetDraftPolicy" - OpenShell_ApproveDraftChunk_FullMethodName = "/openshell.v1.OpenShell/ApproveDraftChunk" - OpenShell_RejectDraftChunk_FullMethodName = "/openshell.v1.OpenShell/RejectDraftChunk" - OpenShell_ApproveAllDraftChunks_FullMethodName = "/openshell.v1.OpenShell/ApproveAllDraftChunks" - OpenShell_EditDraftChunk_FullMethodName = "/openshell.v1.OpenShell/EditDraftChunk" - OpenShell_UndoDraftChunk_FullMethodName = "/openshell.v1.OpenShell/UndoDraftChunk" - OpenShell_ClearDraftChunks_FullMethodName = "/openshell.v1.OpenShell/ClearDraftChunks" - OpenShell_GetDraftHistory_FullMethodName = "/openshell.v1.OpenShell/GetDraftHistory" - OpenShell_IssueSandboxToken_FullMethodName = "/openshell.v1.OpenShell/IssueSandboxToken" - OpenShell_RefreshSandboxToken_FullMethodName = "/openshell.v1.OpenShell/RefreshSandboxToken" - OpenShell_CreateWorkspace_FullMethodName = "/openshell.v1.OpenShell/CreateWorkspace" - OpenShell_GetWorkspace_FullMethodName = "/openshell.v1.OpenShell/GetWorkspace" - OpenShell_ListWorkspaces_FullMethodName = "/openshell.v1.OpenShell/ListWorkspaces" - OpenShell_DeleteWorkspace_FullMethodName = "/openshell.v1.OpenShell/DeleteWorkspace" - OpenShell_AddWorkspaceMember_FullMethodName = "/openshell.v1.OpenShell/AddWorkspaceMember" - OpenShell_RemoveWorkspaceMember_FullMethodName = "/openshell.v1.OpenShell/RemoveWorkspaceMember" - OpenShell_ListWorkspaceMembers_FullMethodName = "/openshell.v1.OpenShell/ListWorkspaceMembers" + OpenShell_Health_FullMethodName = "/openshell.v1.OpenShell/Health" + OpenShell_GetCurrentUser_FullMethodName = "/openshell.v1.OpenShell/GetCurrentUser" + OpenShell_GetGatewayInfo_FullMethodName = "/openshell.v1.OpenShell/GetGatewayInfo" + OpenShell_CreateSandbox_FullMethodName = "/openshell.v1.OpenShell/CreateSandbox" + OpenShell_GetSandboxDelegatedIdentityStatus_FullMethodName = "/openshell.v1.OpenShell/GetSandboxDelegatedIdentityStatus" + OpenShell_WithdrawSandboxDelegatedIdentity_FullMethodName = "/openshell.v1.OpenShell/WithdrawSandboxDelegatedIdentity" + OpenShell_ExtendSandboxDelegatedIdentity_FullMethodName = "/openshell.v1.OpenShell/ExtendSandboxDelegatedIdentity" + OpenShell_GetSandbox_FullMethodName = "/openshell.v1.OpenShell/GetSandbox" + OpenShell_ListSandboxes_FullMethodName = "/openshell.v1.OpenShell/ListSandboxes" + OpenShell_ListSandboxProviders_FullMethodName = "/openshell.v1.OpenShell/ListSandboxProviders" + OpenShell_AttachSandboxProvider_FullMethodName = "/openshell.v1.OpenShell/AttachSandboxProvider" + OpenShell_DetachSandboxProvider_FullMethodName = "/openshell.v1.OpenShell/DetachSandboxProvider" + OpenShell_DeleteSandbox_FullMethodName = "/openshell.v1.OpenShell/DeleteSandbox" + OpenShell_StopSandbox_FullMethodName = "/openshell.v1.OpenShell/StopSandbox" + OpenShell_StartSandbox_FullMethodName = "/openshell.v1.OpenShell/StartSandbox" + OpenShell_CreateSshSession_FullMethodName = "/openshell.v1.OpenShell/CreateSshSession" + OpenShell_ExposeService_FullMethodName = "/openshell.v1.OpenShell/ExposeService" + OpenShell_GetService_FullMethodName = "/openshell.v1.OpenShell/GetService" + OpenShell_ListServices_FullMethodName = "/openshell.v1.OpenShell/ListServices" + OpenShell_DeleteService_FullMethodName = "/openshell.v1.OpenShell/DeleteService" + OpenShell_RevokeSshSession_FullMethodName = "/openshell.v1.OpenShell/RevokeSshSession" + OpenShell_ExecSandbox_FullMethodName = "/openshell.v1.OpenShell/ExecSandbox" + OpenShell_ForwardTcp_FullMethodName = "/openshell.v1.OpenShell/ForwardTcp" + OpenShell_ExecSandboxInteractive_FullMethodName = "/openshell.v1.OpenShell/ExecSandboxInteractive" + OpenShell_CreateProvider_FullMethodName = "/openshell.v1.OpenShell/CreateProvider" + OpenShell_GetProvider_FullMethodName = "/openshell.v1.OpenShell/GetProvider" + OpenShell_ListProviders_FullMethodName = "/openshell.v1.OpenShell/ListProviders" + OpenShell_ListProviderProfiles_FullMethodName = "/openshell.v1.OpenShell/ListProviderProfiles" + OpenShell_GetProviderProfile_FullMethodName = "/openshell.v1.OpenShell/GetProviderProfile" + OpenShell_ImportProviderProfiles_FullMethodName = "/openshell.v1.OpenShell/ImportProviderProfiles" + OpenShell_UpdateProviderProfiles_FullMethodName = "/openshell.v1.OpenShell/UpdateProviderProfiles" + OpenShell_LintProviderProfiles_FullMethodName = "/openshell.v1.OpenShell/LintProviderProfiles" + OpenShell_UpdateProvider_FullMethodName = "/openshell.v1.OpenShell/UpdateProvider" + OpenShell_GetProviderRefreshStatus_FullMethodName = "/openshell.v1.OpenShell/GetProviderRefreshStatus" + OpenShell_ConfigureProviderRefresh_FullMethodName = "/openshell.v1.OpenShell/ConfigureProviderRefresh" + OpenShell_RotateProviderCredential_FullMethodName = "/openshell.v1.OpenShell/RotateProviderCredential" + OpenShell_ListDelegatedIdentityCredentials_FullMethodName = "/openshell.v1.OpenShell/ListDelegatedIdentityCredentials" + OpenShell_GetDelegatedIdentityCredentialStatus_FullMethodName = "/openshell.v1.OpenShell/GetDelegatedIdentityCredentialStatus" + OpenShell_RevokeDelegatedIdentityCredential_FullMethodName = "/openshell.v1.OpenShell/RevokeDelegatedIdentityCredential" + OpenShell_DeleteDelegatedIdentityCredential_FullMethodName = "/openshell.v1.OpenShell/DeleteDelegatedIdentityCredential" + OpenShell_DeleteProviderRefresh_FullMethodName = "/openshell.v1.OpenShell/DeleteProviderRefresh" + OpenShell_DeleteProvider_FullMethodName = "/openshell.v1.OpenShell/DeleteProvider" + OpenShell_DeleteProviderProfile_FullMethodName = "/openshell.v1.OpenShell/DeleteProviderProfile" + OpenShell_GetSandboxConfig_FullMethodName = "/openshell.v1.OpenShell/GetSandboxConfig" + OpenShell_GetGatewayConfig_FullMethodName = "/openshell.v1.OpenShell/GetGatewayConfig" + OpenShell_UpdateConfig_FullMethodName = "/openshell.v1.OpenShell/UpdateConfig" + OpenShell_GetSandboxPolicyStatus_FullMethodName = "/openshell.v1.OpenShell/GetSandboxPolicyStatus" + OpenShell_ListSandboxPolicies_FullMethodName = "/openshell.v1.OpenShell/ListSandboxPolicies" + OpenShell_ReportPolicyStatus_FullMethodName = "/openshell.v1.OpenShell/ReportPolicyStatus" + OpenShell_GetSandboxProviderEnvironment_FullMethodName = "/openshell.v1.OpenShell/GetSandboxProviderEnvironment" + OpenShell_ExchangeProviderSubjectToken_FullMethodName = "/openshell.v1.OpenShell/ExchangeProviderSubjectToken" + OpenShell_GetSandboxLogs_FullMethodName = "/openshell.v1.OpenShell/GetSandboxLogs" + OpenShell_PushSandboxLogs_FullMethodName = "/openshell.v1.OpenShell/PushSandboxLogs" + OpenShell_ConnectSupervisor_FullMethodName = "/openshell.v1.OpenShell/ConnectSupervisor" + OpenShell_ReportMainProcessExit_FullMethodName = "/openshell.v1.OpenShell/ReportMainProcessExit" + OpenShell_FinalizeMainProcessExit_FullMethodName = "/openshell.v1.OpenShell/FinalizeMainProcessExit" + OpenShell_RelayStream_FullMethodName = "/openshell.v1.OpenShell/RelayStream" + OpenShell_WatchSandbox_FullMethodName = "/openshell.v1.OpenShell/WatchSandbox" + OpenShell_SubmitPolicyAnalysis_FullMethodName = "/openshell.v1.OpenShell/SubmitPolicyAnalysis" + OpenShell_GetDraftPolicy_FullMethodName = "/openshell.v1.OpenShell/GetDraftPolicy" + OpenShell_ApproveDraftChunk_FullMethodName = "/openshell.v1.OpenShell/ApproveDraftChunk" + OpenShell_RejectDraftChunk_FullMethodName = "/openshell.v1.OpenShell/RejectDraftChunk" + OpenShell_ApproveAllDraftChunks_FullMethodName = "/openshell.v1.OpenShell/ApproveAllDraftChunks" + OpenShell_EditDraftChunk_FullMethodName = "/openshell.v1.OpenShell/EditDraftChunk" + OpenShell_UndoDraftChunk_FullMethodName = "/openshell.v1.OpenShell/UndoDraftChunk" + OpenShell_ClearDraftChunks_FullMethodName = "/openshell.v1.OpenShell/ClearDraftChunks" + OpenShell_GetDraftHistory_FullMethodName = "/openshell.v1.OpenShell/GetDraftHistory" + OpenShell_IssueSandboxToken_FullMethodName = "/openshell.v1.OpenShell/IssueSandboxToken" + OpenShell_RefreshSandboxToken_FullMethodName = "/openshell.v1.OpenShell/RefreshSandboxToken" + OpenShell_CreateWorkspace_FullMethodName = "/openshell.v1.OpenShell/CreateWorkspace" + OpenShell_GetWorkspace_FullMethodName = "/openshell.v1.OpenShell/GetWorkspace" + OpenShell_ListWorkspaces_FullMethodName = "/openshell.v1.OpenShell/ListWorkspaces" + OpenShell_DeleteWorkspace_FullMethodName = "/openshell.v1.OpenShell/DeleteWorkspace" + OpenShell_AddWorkspaceMember_FullMethodName = "/openshell.v1.OpenShell/AddWorkspaceMember" + OpenShell_RemoveWorkspaceMember_FullMethodName = "/openshell.v1.OpenShell/RemoveWorkspaceMember" + OpenShell_ListWorkspaceMembers_FullMethodName = "/openshell.v1.OpenShell/ListWorkspaceMembers" ) // OpenShellClient is the client API for OpenShell service. @@ -115,6 +122,12 @@ type OpenShellClient interface { GetGatewayInfo(ctx context.Context, in *GetGatewayInfoRequest, opts ...grpc.CallOption) (*GetGatewayInfoResponse, error) // Create a new sandbox. CreateSandbox(ctx context.Context, in *CreateSandboxRequest, opts ...grpc.CallOption) (*SandboxResponse, error) + // Fetch delegated identity status for one sandbox. + GetSandboxDelegatedIdentityStatus(ctx context.Context, in *GetSandboxDelegatedIdentityStatusRequest, opts ...grpc.CallOption) (*GetSandboxDelegatedIdentityStatusResponse, error) + // Withdraw delegated identity from one sandbox. + WithdrawSandboxDelegatedIdentity(ctx context.Context, in *WithdrawSandboxDelegatedIdentityRequest, opts ...grpc.CallOption) (*WithdrawSandboxDelegatedIdentityResponse, error) + // Extend delegated identity for one sandbox. + ExtendSandboxDelegatedIdentity(ctx context.Context, in *ExtendSandboxDelegatedIdentityRequest, opts ...grpc.CallOption) (*ExtendSandboxDelegatedIdentityResponse, error) // Fetch a sandbox by name. GetSandbox(ctx context.Context, in *GetSandboxRequest, opts ...grpc.CallOption) (*SandboxResponse, error) // List sandboxes. @@ -175,6 +188,14 @@ type OpenShellClient interface { ConfigureProviderRefresh(ctx context.Context, in *ConfigureProviderRefreshRequest, opts ...grpc.CallOption) (*ConfigureProviderRefreshResponse, error) // Record a gateway-owned refresh request for one provider credential. RotateProviderCredential(ctx context.Context, in *RotateProviderCredentialRequest, opts ...grpc.CallOption) (*RotateProviderCredentialResponse, error) + // List delegated identity credentials visible to the caller. + ListDelegatedIdentityCredentials(ctx context.Context, in *ListDelegatedIdentityCredentialsRequest, opts ...grpc.CallOption) (*ListDelegatedIdentityCredentialsResponse, error) + // Fetch delegated identity credential status. + GetDelegatedIdentityCredentialStatus(ctx context.Context, in *GetDelegatedIdentityCredentialStatusRequest, opts ...grpc.CallOption) (*GetDelegatedIdentityCredentialStatusResponse, error) + // Revoke a delegated identity credential. + RevokeDelegatedIdentityCredential(ctx context.Context, in *RevokeDelegatedIdentityCredentialRequest, opts ...grpc.CallOption) (*RevokeDelegatedIdentityCredentialResponse, error) + // Delete a delegated identity credential. + DeleteDelegatedIdentityCredential(ctx context.Context, in *DeleteDelegatedIdentityCredentialRequest, opts ...grpc.CallOption) (*DeleteDelegatedIdentityCredentialResponse, error) // Delete gateway-owned refresh configuration for one provider credential. DeleteProviderRefresh(ctx context.Context, in *DeleteProviderRefreshRequest, opts ...grpc.CallOption) (*DeleteProviderRefreshResponse, error) // Delete a provider by name. @@ -335,6 +356,36 @@ func (c *openShellClient) CreateSandbox(ctx context.Context, in *CreateSandboxRe return out, nil } +func (c *openShellClient) GetSandboxDelegatedIdentityStatus(ctx context.Context, in *GetSandboxDelegatedIdentityStatusRequest, opts ...grpc.CallOption) (*GetSandboxDelegatedIdentityStatusResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetSandboxDelegatedIdentityStatusResponse) + err := c.cc.Invoke(ctx, OpenShell_GetSandboxDelegatedIdentityStatus_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *openShellClient) WithdrawSandboxDelegatedIdentity(ctx context.Context, in *WithdrawSandboxDelegatedIdentityRequest, opts ...grpc.CallOption) (*WithdrawSandboxDelegatedIdentityResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(WithdrawSandboxDelegatedIdentityResponse) + err := c.cc.Invoke(ctx, OpenShell_WithdrawSandboxDelegatedIdentity_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *openShellClient) ExtendSandboxDelegatedIdentity(ctx context.Context, in *ExtendSandboxDelegatedIdentityRequest, opts ...grpc.CallOption) (*ExtendSandboxDelegatedIdentityResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ExtendSandboxDelegatedIdentityResponse) + err := c.cc.Invoke(ctx, OpenShell_ExtendSandboxDelegatedIdentity_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *openShellClient) GetSandbox(ctx context.Context, in *GetSandboxRequest, opts ...grpc.CallOption) (*SandboxResponse, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(SandboxResponse) @@ -640,6 +691,46 @@ func (c *openShellClient) RotateProviderCredential(ctx context.Context, in *Rota return out, nil } +func (c *openShellClient) ListDelegatedIdentityCredentials(ctx context.Context, in *ListDelegatedIdentityCredentialsRequest, opts ...grpc.CallOption) (*ListDelegatedIdentityCredentialsResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ListDelegatedIdentityCredentialsResponse) + err := c.cc.Invoke(ctx, OpenShell_ListDelegatedIdentityCredentials_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *openShellClient) GetDelegatedIdentityCredentialStatus(ctx context.Context, in *GetDelegatedIdentityCredentialStatusRequest, opts ...grpc.CallOption) (*GetDelegatedIdentityCredentialStatusResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetDelegatedIdentityCredentialStatusResponse) + err := c.cc.Invoke(ctx, OpenShell_GetDelegatedIdentityCredentialStatus_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *openShellClient) RevokeDelegatedIdentityCredential(ctx context.Context, in *RevokeDelegatedIdentityCredentialRequest, opts ...grpc.CallOption) (*RevokeDelegatedIdentityCredentialResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(RevokeDelegatedIdentityCredentialResponse) + err := c.cc.Invoke(ctx, OpenShell_RevokeDelegatedIdentityCredential_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *openShellClient) DeleteDelegatedIdentityCredential(ctx context.Context, in *DeleteDelegatedIdentityCredentialRequest, opts ...grpc.CallOption) (*DeleteDelegatedIdentityCredentialResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(DeleteDelegatedIdentityCredentialResponse) + err := c.cc.Invoke(ctx, OpenShell_DeleteDelegatedIdentityCredential_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *openShellClient) DeleteProviderRefresh(ctx context.Context, in *DeleteProviderRefreshRequest, opts ...grpc.CallOption) (*DeleteProviderRefreshResponse, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(DeleteProviderRefreshResponse) @@ -1039,6 +1130,12 @@ type OpenShellServer interface { GetGatewayInfo(context.Context, *GetGatewayInfoRequest) (*GetGatewayInfoResponse, error) // Create a new sandbox. CreateSandbox(context.Context, *CreateSandboxRequest) (*SandboxResponse, error) + // Fetch delegated identity status for one sandbox. + GetSandboxDelegatedIdentityStatus(context.Context, *GetSandboxDelegatedIdentityStatusRequest) (*GetSandboxDelegatedIdentityStatusResponse, error) + // Withdraw delegated identity from one sandbox. + WithdrawSandboxDelegatedIdentity(context.Context, *WithdrawSandboxDelegatedIdentityRequest) (*WithdrawSandboxDelegatedIdentityResponse, error) + // Extend delegated identity for one sandbox. + ExtendSandboxDelegatedIdentity(context.Context, *ExtendSandboxDelegatedIdentityRequest) (*ExtendSandboxDelegatedIdentityResponse, error) // Fetch a sandbox by name. GetSandbox(context.Context, *GetSandboxRequest) (*SandboxResponse, error) // List sandboxes. @@ -1099,6 +1196,14 @@ type OpenShellServer interface { ConfigureProviderRefresh(context.Context, *ConfigureProviderRefreshRequest) (*ConfigureProviderRefreshResponse, error) // Record a gateway-owned refresh request for one provider credential. RotateProviderCredential(context.Context, *RotateProviderCredentialRequest) (*RotateProviderCredentialResponse, error) + // List delegated identity credentials visible to the caller. + ListDelegatedIdentityCredentials(context.Context, *ListDelegatedIdentityCredentialsRequest) (*ListDelegatedIdentityCredentialsResponse, error) + // Fetch delegated identity credential status. + GetDelegatedIdentityCredentialStatus(context.Context, *GetDelegatedIdentityCredentialStatusRequest) (*GetDelegatedIdentityCredentialStatusResponse, error) + // Revoke a delegated identity credential. + RevokeDelegatedIdentityCredential(context.Context, *RevokeDelegatedIdentityCredentialRequest) (*RevokeDelegatedIdentityCredentialResponse, error) + // Delete a delegated identity credential. + DeleteDelegatedIdentityCredential(context.Context, *DeleteDelegatedIdentityCredentialRequest) (*DeleteDelegatedIdentityCredentialResponse, error) // Delete gateway-owned refresh configuration for one provider credential. DeleteProviderRefresh(context.Context, *DeleteProviderRefreshRequest) (*DeleteProviderRefreshResponse, error) // Delete a provider by name. @@ -1231,6 +1336,15 @@ func (UnimplementedOpenShellServer) GetGatewayInfo(context.Context, *GetGatewayI func (UnimplementedOpenShellServer) CreateSandbox(context.Context, *CreateSandboxRequest) (*SandboxResponse, error) { return nil, status.Error(codes.Unimplemented, "method CreateSandbox not implemented") } +func (UnimplementedOpenShellServer) GetSandboxDelegatedIdentityStatus(context.Context, *GetSandboxDelegatedIdentityStatusRequest) (*GetSandboxDelegatedIdentityStatusResponse, error) { + return nil, status.Error(codes.Unimplemented, "method GetSandboxDelegatedIdentityStatus not implemented") +} +func (UnimplementedOpenShellServer) WithdrawSandboxDelegatedIdentity(context.Context, *WithdrawSandboxDelegatedIdentityRequest) (*WithdrawSandboxDelegatedIdentityResponse, error) { + return nil, status.Error(codes.Unimplemented, "method WithdrawSandboxDelegatedIdentity not implemented") +} +func (UnimplementedOpenShellServer) ExtendSandboxDelegatedIdentity(context.Context, *ExtendSandboxDelegatedIdentityRequest) (*ExtendSandboxDelegatedIdentityResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ExtendSandboxDelegatedIdentity not implemented") +} func (UnimplementedOpenShellServer) GetSandbox(context.Context, *GetSandboxRequest) (*SandboxResponse, error) { return nil, status.Error(codes.Unimplemented, "method GetSandbox not implemented") } @@ -1318,6 +1432,18 @@ func (UnimplementedOpenShellServer) ConfigureProviderRefresh(context.Context, *C func (UnimplementedOpenShellServer) RotateProviderCredential(context.Context, *RotateProviderCredentialRequest) (*RotateProviderCredentialResponse, error) { return nil, status.Error(codes.Unimplemented, "method RotateProviderCredential not implemented") } +func (UnimplementedOpenShellServer) ListDelegatedIdentityCredentials(context.Context, *ListDelegatedIdentityCredentialsRequest) (*ListDelegatedIdentityCredentialsResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ListDelegatedIdentityCredentials not implemented") +} +func (UnimplementedOpenShellServer) GetDelegatedIdentityCredentialStatus(context.Context, *GetDelegatedIdentityCredentialStatusRequest) (*GetDelegatedIdentityCredentialStatusResponse, error) { + return nil, status.Error(codes.Unimplemented, "method GetDelegatedIdentityCredentialStatus not implemented") +} +func (UnimplementedOpenShellServer) RevokeDelegatedIdentityCredential(context.Context, *RevokeDelegatedIdentityCredentialRequest) (*RevokeDelegatedIdentityCredentialResponse, error) { + return nil, status.Error(codes.Unimplemented, "method RevokeDelegatedIdentityCredential not implemented") +} +func (UnimplementedOpenShellServer) DeleteDelegatedIdentityCredential(context.Context, *DeleteDelegatedIdentityCredentialRequest) (*DeleteDelegatedIdentityCredentialResponse, error) { + return nil, status.Error(codes.Unimplemented, "method DeleteDelegatedIdentityCredential not implemented") +} func (UnimplementedOpenShellServer) DeleteProviderRefresh(context.Context, *DeleteProviderRefreshRequest) (*DeleteProviderRefreshResponse, error) { return nil, status.Error(codes.Unimplemented, "method DeleteProviderRefresh not implemented") } @@ -1519,6 +1645,60 @@ func _OpenShell_CreateSandbox_Handler(srv interface{}, ctx context.Context, dec return interceptor(ctx, in, info, handler) } +func _OpenShell_GetSandboxDelegatedIdentityStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetSandboxDelegatedIdentityStatusRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(OpenShellServer).GetSandboxDelegatedIdentityStatus(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: OpenShell_GetSandboxDelegatedIdentityStatus_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(OpenShellServer).GetSandboxDelegatedIdentityStatus(ctx, req.(*GetSandboxDelegatedIdentityStatusRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _OpenShell_WithdrawSandboxDelegatedIdentity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(WithdrawSandboxDelegatedIdentityRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(OpenShellServer).WithdrawSandboxDelegatedIdentity(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: OpenShell_WithdrawSandboxDelegatedIdentity_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(OpenShellServer).WithdrawSandboxDelegatedIdentity(ctx, req.(*WithdrawSandboxDelegatedIdentityRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _OpenShell_ExtendSandboxDelegatedIdentity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ExtendSandboxDelegatedIdentityRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(OpenShellServer).ExtendSandboxDelegatedIdentity(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: OpenShell_ExtendSandboxDelegatedIdentity_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(OpenShellServer).ExtendSandboxDelegatedIdentity(ctx, req.(*ExtendSandboxDelegatedIdentityRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _OpenShell_GetSandbox_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetSandboxRequest) if err := dec(in); err != nil { @@ -2012,6 +2192,78 @@ func _OpenShell_RotateProviderCredential_Handler(srv interface{}, ctx context.Co return interceptor(ctx, in, info, handler) } +func _OpenShell_ListDelegatedIdentityCredentials_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListDelegatedIdentityCredentialsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(OpenShellServer).ListDelegatedIdentityCredentials(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: OpenShell_ListDelegatedIdentityCredentials_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(OpenShellServer).ListDelegatedIdentityCredentials(ctx, req.(*ListDelegatedIdentityCredentialsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _OpenShell_GetDelegatedIdentityCredentialStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetDelegatedIdentityCredentialStatusRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(OpenShellServer).GetDelegatedIdentityCredentialStatus(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: OpenShell_GetDelegatedIdentityCredentialStatus_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(OpenShellServer).GetDelegatedIdentityCredentialStatus(ctx, req.(*GetDelegatedIdentityCredentialStatusRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _OpenShell_RevokeDelegatedIdentityCredential_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RevokeDelegatedIdentityCredentialRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(OpenShellServer).RevokeDelegatedIdentityCredential(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: OpenShell_RevokeDelegatedIdentityCredential_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(OpenShellServer).RevokeDelegatedIdentityCredential(ctx, req.(*RevokeDelegatedIdentityCredentialRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _OpenShell_DeleteDelegatedIdentityCredential_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeleteDelegatedIdentityCredentialRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(OpenShellServer).DeleteDelegatedIdentityCredential(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: OpenShell_DeleteDelegatedIdentityCredential_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(OpenShellServer).DeleteDelegatedIdentityCredential(ctx, req.(*DeleteDelegatedIdentityCredentialRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _OpenShell_DeleteProviderRefresh_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(DeleteProviderRefreshRequest) if err := dec(in); err != nil { @@ -2643,6 +2895,18 @@ var OpenShell_ServiceDesc = grpc.ServiceDesc{ MethodName: "CreateSandbox", Handler: _OpenShell_CreateSandbox_Handler, }, + { + MethodName: "GetSandboxDelegatedIdentityStatus", + Handler: _OpenShell_GetSandboxDelegatedIdentityStatus_Handler, + }, + { + MethodName: "WithdrawSandboxDelegatedIdentity", + Handler: _OpenShell_WithdrawSandboxDelegatedIdentity_Handler, + }, + { + MethodName: "ExtendSandboxDelegatedIdentity", + Handler: _OpenShell_ExtendSandboxDelegatedIdentity_Handler, + }, { MethodName: "GetSandbox", Handler: _OpenShell_GetSandbox_Handler, @@ -2747,6 +3011,22 @@ var OpenShell_ServiceDesc = grpc.ServiceDesc{ MethodName: "RotateProviderCredential", Handler: _OpenShell_RotateProviderCredential_Handler, }, + { + MethodName: "ListDelegatedIdentityCredentials", + Handler: _OpenShell_ListDelegatedIdentityCredentials_Handler, + }, + { + MethodName: "GetDelegatedIdentityCredentialStatus", + Handler: _OpenShell_GetDelegatedIdentityCredentialStatus_Handler, + }, + { + MethodName: "RevokeDelegatedIdentityCredential", + Handler: _OpenShell_RevokeDelegatedIdentityCredential_Handler, + }, + { + MethodName: "DeleteDelegatedIdentityCredential", + Handler: _OpenShell_DeleteDelegatedIdentityCredential_Handler, + }, { MethodName: "DeleteProviderRefresh", Handler: _OpenShell_DeleteProviderRefresh_Handler,