From 54d10450675eb093986f9c869a65653706c1ee7d Mon Sep 17 00:00:00 2001 From: Drew Newberry Date: Wed, 12 Aug 2026 13:37:54 -0700 Subject: [PATCH 1/8] feat(sandbox): add canonical main process Closes #2710 Persist and supervise one canonical workload per sandbox, attach sandbox connect to its retained session, and make every unexpected main-process exit terminal. Signed-off-by: Drew Newberry --- .agents/skills/openshell-cli/SKILL.md | 18 +- Cargo.lock | 1 + architecture/compute-runtimes.md | 7 + architecture/gateway.md | 6 + architecture/sandbox.md | 17 +- crates/openshell-cli/src/main.rs | 62 +- crates/openshell-cli/src/run.rs | 92 +- crates/openshell-cli/src/ssh.rs | 27 +- .../sandbox_create_lifecycle_integration.rs | 39 + crates/openshell-core/src/driver_utils.rs | 1 + crates/openshell-core/src/sandbox_env.rs | 96 + crates/openshell-driver-docker/README.md | 4 +- crates/openshell-driver-docker/src/lib.rs | 21 +- crates/openshell-driver-docker/src/tests.rs | 13 +- crates/openshell-driver-kubernetes/README.md | 5 + .../openshell-driver-kubernetes/src/driver.rs | 23 +- crates/openshell-driver-podman/README.md | 2 +- .../openshell-driver-podman/src/container.rs | 8 +- crates/openshell-driver-vm/README.md | 4 + crates/openshell-driver-vm/src/driver.rs | 104 +- crates/openshell-sandbox/Cargo.toml | 1 + crates/openshell-sandbox/src/lib.rs | 154 +- crates/openshell-sandbox/src/main.rs | 45 +- .../openshell-sandbox/src/sidecar_control.rs | 129 +- crates/openshell-sdk/src/client.rs | 32 + crates/openshell-sdk/src/lib.rs | 4 +- crates/openshell-sdk/src/types.rs | 36 + crates/openshell-server/src/compute/mod.rs | 426 ++- crates/openshell-server/src/grpc/mod.rs | 1 + crates/openshell-server/src/grpc/sandbox.rs | 20 +- .../openshell-server/src/grpc/validation.rs | 114 +- .../src/supervisor_session.rs | 91 +- crates/openshell-server/src/test_support.rs | 1 + .../openshell-supervisor-process/src/lib.rs | 1 + .../src/main_session.rs | 320 ++ .../src/process.rs | 174 +- .../openshell-supervisor-process/src/run.rs | 180 +- .../openshell-supervisor-process/src/ssh.rs | 299 +- .../src/supervisor_session.rs | 65 +- docs/observability/accessing-logs.mdx | 11 +- docs/reference/sandbox-compute-drivers.mdx | 6 + docs/sandboxes/manage-sandboxes.mdx | 26 +- docs/sandboxes/policies.mdx | 4 +- e2e/rust/src/harness/sandbox.rs | 135 +- e2e/rust/tests/local_driver_token_restart.rs | 68 +- e2e/rust/tests/provider_auto_create.rs | 44 +- e2e/rust/tests/sandbox_labels.rs | 6 +- e2e/rust/tests/sandbox_lifecycle.rs | 42 +- proto/compute_driver.proto | 14 + proto/openshell.proto | 59 + python/openshell/_proto/__init__.py | 8 +- python/openshell/sandbox.py | 28 + python/openshell/sandbox_test.py | 19 + .../openshell/v1/internal/converter/copy.go | 9 + .../v1/internal/converter/coverage_test.go | 2 + .../v1/internal/converter/sandbox.go | 27 + .../v1/internal/converter/sandbox_test.go | 38 + sdk/go/openshell/v1/types/sandbox.go | 22 +- sdk/go/proto/openshellv1/openshell.pb.go | 2646 ++++++++++------- 59 files changed, 4401 insertions(+), 1456 deletions(-) create mode 100644 crates/openshell-supervisor-process/src/main_session.rs diff --git a/.agents/skills/openshell-cli/SKILL.md b/.agents/skills/openshell-cli/SKILL.md index 1cee3d5c37..31dbfdb224 100644 --- a/.agents/skills/openshell-cli/SKILL.md +++ b/.agents/skills/openshell-cli/SKILL.md @@ -70,7 +70,9 @@ The simplest way to get a sandbox running: openshell sandbox create ``` -This creates a sandbox with defaults and drops you into an interactive shell. +This creates a sandbox whose canonical main process is `/bin/bash -l` and +attaches your terminal to that retained process. Add `--detach` to return after +the sandbox becomes ready without attaching. When supplying `--name`, use a portable DNS-1123 label: at most 63 lowercase alphanumeric or `-` characters, beginning and ending with an alphanumeric character. The Kubernetes driver rejects uppercase letters, underscores, dots, and other names that cannot become Kubernetes resource labels. @@ -223,9 +225,14 @@ Key flags: - `--upload [:]`: Upload local files into the container working directory or an explicit destination - `--no-git-ignore`: Disable `.gitignore` filtering for uploads - `--no-keep`: Delete the sandbox after the initial command or shell exits +- `--detach`: Start the canonical main process without attaching - `--forward [BIND_ADDRESS:]PORT`: Forward a local port and keep the sandbox alive - `--editor vscode|cursor`: Open a remote editor after creation and keep the sandbox alive +Do not combine `--upload` with a trailing main command. Uploads currently finish +after the canonical process starts; create a scratch sandbox and use +`sandbox exec`, or build the files into the image. + ### List and inspect sandboxes ```bash @@ -243,7 +250,10 @@ openshell sandbox connect my-sandbox openshell sandbox connect my-sandbox --editor vscode ``` -Opens an interactive SSH shell. To configure VS Code Remote-SSH: +Attaches to the sandbox's existing canonical main process. Disconnecting leaves +that process running; reconnecting targets the same generation and replays +recent output. Use `sandbox exec --tty -- /bin/bash -l` for a new shell. To +configure VS Code Remote-SSH: ```bash openshell sandbox ssh-config my-sandbox >> ~/.ssh/config @@ -276,7 +286,9 @@ openshell sandbox exec --name my-sandbox --workdir /workspace -- ls -la openshell sandbox exec --name my-sandbox --env MODE=test -- cargo test ``` -`sandbox exec` streams output and exits with the remote command's exit code. Use `sandbox connect` for an interactive shell. +`sandbox exec` starts an independent sibling process, streams output, and exits +with the remote command's exit code. Use `sandbox connect` to attach to the +canonical main process. Use `--env` only for non-secret values. Attach credentials to the sandbox with a provider instead of passing API keys, tokens, or other secrets to `sandbox exec`. diff --git a/Cargo.lock b/Cargo.lock index c30f890914..6c68ca883b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4057,6 +4057,7 @@ dependencies = [ "tracing", "tracing-appender", "tracing-subscriber", + "uuid", ] [[package]] diff --git a/architecture/compute-runtimes.md b/architecture/compute-runtimes.md index 831be067ab..a2be242603 100644 --- a/architecture/compute-runtimes.md +++ b/architecture/compute-runtimes.md @@ -13,6 +13,8 @@ Each runtime receives a sandbox spec from the gateway and is responsible for: - Injecting sandbox identity and gateway callback configuration. - Supplying TLS or secret material for supervisor callbacks. - Providing the supervisor binary or image in the workload. +- Forwarding the exact canonical main-process argv, environment, working + directory, and terminal mode without shell reconstruction. - Reporting lifecycle and platform events back to the gateway. - Cleaning up runtime-owned resources. @@ -23,6 +25,11 @@ references to gateway-internal types. The gateway owns the public `SandboxPhase::Ready` decision. This applies equally to extension drivers implementing `ComputeDriver` out of tree. +Drivers advertise canonical-process support in `GetCapabilities`. The gateway +rejects creation through older extension drivers that do not advertise the +capability, preventing a legacy idle entrypoint from silently replacing the +requested workload. + Drivers own runtime-specific platform event interpretation. When an event should drive client provisioning UI, the driver attaches the shared `openshell.progress.*` metadata defined in `openshell-core` instead of requiring diff --git a/architecture/gateway.md b/architecture/gateway.md index db8f2508e8..cf9d9a88e2 100644 --- a/architecture/gateway.md +++ b/architecture/gateway.md @@ -15,11 +15,17 @@ workloads. - Resolve provider credentials and inference bundles for sandbox supervisors. - Coordinate supervisor relay sessions for connect, exec, file sync, and service forwarding. +- Persist the canonical main-process generation and terminal result. Any main + process exit transitions the sandbox to `Error`, including exit code zero. The gateway does not enforce agent network policy at request time. That happens inside each sandbox, where the supervisor and proxy can observe local process identity. +The live supervisor session is the readiness authority for its main-process +generation. Short-lived exit-report sessions never replace that session or +mark the sandbox ready, and the gateway rejects stale generation results. + ## Protocol and Auth The gateway listens on one service port and multiplexes gRPC and HTTP traffic. diff --git a/architecture/sandbox.md b/architecture/sandbox.md index 698f88a80a..ddb1f95c81 100644 --- a/architecture/sandbox.md +++ b/architecture/sandbox.md @@ -29,10 +29,11 @@ only when the set is already empty; any other outcome fails the spawn. gateway, depending on mode. 3. It prepares filesystem access, process restrictions, network namespace routing, trust stores, provider credential resolution, and inference routes. -4. It starts the policy proxy and local SSH server. -5. It opens a supervisor session back to the gateway for connect, exec, file +4. It launches the persisted canonical main-process argv and retains its PTY + or pipes in the main-session multiplexer. +5. It starts the policy proxy and local SSH server. +6. It opens a supervisor session back to the gateway for connect, exec, file sync, config polling, and log push. -6. It launches the agent command as the resolved restricted identity. ## Isolation Layers @@ -326,8 +327,10 @@ The supervisor runs an SSH server on a Unix socket inside the sandbox. The gateway reaches it through the outbound supervisor relay, not by dialing the sandbox workload directly. The relay supports: -- Interactive shell sessions. -- Command execution. +- Attachment to the canonical main process through the `openshell-main` SSH + subsystem. The supervisor owns its retained PTY or pipes, a 1 MiB replay + buffer, and a single stdin lease across client disconnects. +- Independent shell and command execution sessions. - Tar-based file sync. - Port forwarding where supported by the CLI/TUI surface. @@ -403,3 +406,7 @@ engine with a gateway policy revision. re-evaluate. - If the supervisor relay drops, the sandbox can keep running, but connect and exec operations fail until the supervisor registers again. +- If the canonical main process exits, including with code 0, the supervisor + reports its result before shutdown. The gateway persists `MainProcessExited` + and makes the sandbox terminal `Error`; runtime restart policies must not + replace the process generation. diff --git a/crates/openshell-cli/src/main.rs b/crates/openshell-cli/src/main.rs index b49bb7bd36..5ab8fad6ab 100644 --- a/crates/openshell-cli/src/main.rs +++ b/crates/openshell-cli/src/main.rs @@ -1348,7 +1348,12 @@ enum SandboxCommands { /// working directory. /// `.gitignore` rules are applied by default; use `--no-git-ignore` to /// upload everything. - #[arg(long, value_hint = ValueHint::AnyPath, help_heading = "UPLOAD FLAGS")] + #[arg( + long, + value_hint = ValueHint::AnyPath, + help_heading = "UPLOAD FLAGS", + conflicts_with = "command" + )] upload: Vec, /// Disable `.gitignore` filtering for `--upload`. @@ -1418,6 +1423,10 @@ enum SandboxCommands { #[arg(long, overrides_with = "tty")] no_tty: bool, + /// Start the canonical main process without attaching to it. + #[arg(long, conflicts_with_all = ["editor", "no_keep"])] + detach: bool, + /// Auto-create missing providers from local credentials. /// /// Without this flag, an interactive prompt asks per-provider; @@ -2977,6 +2986,7 @@ async fn run_async() -> Result<()> { forward, tty, no_tty, + detach, auto_providers, no_auto_providers, labels, @@ -3072,6 +3082,7 @@ async fn run_async() -> Result<()> { environment: env_map, approval_mode: &approval_mode, output: output.as_str(), + detach, }, &cli.workspace, &tls, @@ -5125,6 +5136,55 @@ mod tests { } } + #[test] + fn sandbox_create_detach_parses_with_main_command() { + let cli = Cli::try_parse_from([ + "openshell", + "sandbox", + "create", + "--detach", + "--", + "worker", + "--serve", + ]) + .expect("sandbox create --detach should parse"); + + match cli.command { + Some(Commands::Sandbox { + command: + Some(SandboxCommands::Create { + detach, command, .. + }), + .. + }) => { + assert!(detach); + assert_eq!(command, ["worker", "--serve"]); + } + other => panic!("expected SandboxCommands::Create, got: {other:?}"), + } + } + + #[test] + fn sandbox_create_detach_rejects_ephemeral_sandbox() { + let result = + Cli::try_parse_from(["openshell", "sandbox", "create", "--detach", "--no-keep"]); + assert!(result.is_err()); + } + + #[test] + fn sandbox_create_rejects_upload_with_main_command() { + let result = Cli::try_parse_from([ + "openshell", + "sandbox", + "create", + "--upload", + ".", + "--", + "./run-uploaded-app", + ]); + assert!(result.is_err()); + } + /// `sandbox create` defaults `--approval-mode` to `"manual"`. The CLI /// always sends an explicit value so the wire form is human-readable /// (the gateway treats `""` as `"manual"` too, but the CLI's job is to diff --git a/crates/openshell-cli/src/run.rs b/crates/openshell-cli/src/run.rs index e376d08dc5..94ec780951 100644 --- a/crates/openshell-cli/src/run.rs +++ b/crates/openshell-cli/src/run.rs @@ -383,6 +383,7 @@ pub struct SandboxCreateConfig<'a> { pub environment: HashMap, pub approval_mode: &'a str, pub output: &'a str, + pub detach: bool, } impl Default for SandboxCreateConfig<'_> { @@ -407,6 +408,7 @@ impl Default for SandboxCreateConfig<'_> { environment: HashMap::new(), approval_mode: "manual", output: "table", + detach: false, } } } @@ -439,6 +441,7 @@ pub async fn sandbox_create( environment, approval_mode, output, + detach, } = config; if editor.is_some() && !command.is_empty() { @@ -446,6 +449,11 @@ pub async fn sandbox_create( "--editor cannot be used with a trailing command; use `openshell sandbox connect --editor ...` after the sandbox is ready" )); } + if !uploads.is_empty() && !command.is_empty() { + return Err(miette::miette!( + "--upload cannot be combined with a trailing main command yet because uploads complete after the canonical process starts" + )); + } // Check port availability *before* creating the sandbox so we don't // leave an orphaned sandbox behind when the forward would fail. @@ -521,6 +529,13 @@ pub async fn sandbox_create( let resource_requirements = gpu_requirements.map(|gpu| ResourceRequirements { gpu: Some(gpu) }); + let main_terminal = tty_override + .unwrap_or_else(|| std::io::stdin().is_terminal() && std::io::stdout().is_terminal()); + let main_command = if command.is_empty() { + vec!["/bin/bash".to_string(), "-l".to_string()] + } else { + command.to_vec() + }; let request = CreateSandboxRequest { spec: Some(SandboxSpec { resource_requirements, @@ -528,6 +543,11 @@ pub async fn sandbox_create( policy, providers: configured_providers, template, + main_process: Some(openshell_core::proto::MainProcessSpec { + command: main_command, + terminal: main_terminal, + ..Default::default() + }), ..SandboxSpec::default() }), name: name.unwrap_or_default().to_string(), @@ -945,53 +965,23 @@ pub async fn sandbox_create( return Ok(()); } - if command.is_empty() { - let connect_result = if persist { - sandbox_connect(&effective_server, &sandbox_name, &effective_tls, workspace) - .await - } else { - crate::ssh::sandbox_connect_without_exec( - &effective_server, - &sandbox_name, - &effective_tls, - workspace, - ) - .await - }; - - return finalize_sandbox_create_session( - &effective_server, - &sandbox_name, - persist, - connect_result, - workspace, - &effective_tls, - gateway_name, - ) - .await; + // Persistent non-interactive creates detach implicitly. An + // explicitly ephemeral (`--no-keep`) create must still attach so + // it can observe the canonical process and delete the sandbox when + // that session ends. + if detach + || (persist + && (!std::io::stdin().is_terminal() || !std::io::stdout().is_terminal())) + { + return Ok(()); } - // Resolve TTY mode: explicit --tty / --no-tty wins, otherwise - // auto-detect from the local terminal. - let tty = tty_override.unwrap_or_else(|| { - std::io::stdin().is_terminal() && std::io::stdout().is_terminal() - }); - let exec_result = if persist { - sandbox_exec( - &effective_server, - &sandbox_name, - command, - tty, - &effective_tls, - workspace, - ) - .await + let connect_result = if persist { + sandbox_connect(&effective_server, &sandbox_name, &effective_tls, workspace).await } else { - crate::ssh::sandbox_exec_without_exec( + crate::ssh::sandbox_connect_without_exec( &effective_server, &sandbox_name, - command, - tty, &effective_tls, workspace, ) @@ -1002,7 +992,7 @@ pub async fn sandbox_create( &effective_server, &sandbox_name, persist, - exec_result, + connect_result, workspace, &effective_tls, gateway_name, @@ -1010,7 +1000,9 @@ pub async fn sandbox_create( .await } SandboxPhase::Error => { - if last_error_reason.is_empty() { + drop(stream); + drop(client); + let create_result = if last_error_reason.is_empty() { Err(miette::miette!( "sandbox entered error phase while provisioning" )) @@ -1019,7 +1011,17 @@ pub async fn sandbox_create( "sandbox entered error phase while provisioning: {}", last_error_reason )) - } + }; + finalize_sandbox_create_session( + &effective_server, + &sandbox_name, + persist, + create_result, + workspace, + &effective_tls, + gateway_name, + ) + .await } _ => Err(miette::miette!( "sandbox provisioning stream ended before reaching terminal phase" diff --git a/crates/openshell-cli/src/ssh.rs b/crates/openshell-cli/src/ssh.rs index 7e5f1e7ee1..939107826a 100644 --- a/crates/openshell-cli/src/ssh.rs +++ b/crates/openshell-cli/src/ssh.rs @@ -71,6 +71,7 @@ struct SshSessionConfig { sandbox_id: String, gateway_url: String, token: String, + main_terminal: bool, } async fn ssh_session_config( @@ -139,6 +140,11 @@ async fn ssh_session_config( sandbox_id: session.sandbox_id.clone(), gateway_url, token: session.token, + main_terminal: sandbox + .spec + .as_ref() + .and_then(|spec| spec.main_process.as_ref()) + .is_none_or(|main| main.terminal), }) } @@ -263,13 +269,17 @@ async fn sandbox_connect_with_mode( let session = ssh_session_config(server, name, tls, workspace).await?; let mut command = ssh_base_command(&session.proxy_command); + if session.main_terminal { + command.arg("-tt").arg("-o").arg("RequestTTY=force"); + } else { + command.arg("-T"); + } command - .arg("-tt") - .arg("-o") - .arg("RequestTTY=force") .arg("-o") .arg("SetEnv=TERM=xterm-256color") + .arg("-s") .arg("sandbox") + .arg("openshell-main") .stdin(Stdio::inherit()) .stdout(Stdio::inherit()) .stderr(Stdio::inherit()); @@ -596,17 +606,6 @@ pub async fn sandbox_exec( sandbox_exec_with_mode(server, name, command, tty, tls, true, workspace).await } -pub(crate) async fn sandbox_exec_without_exec( - server: &str, - name: &str, - command: &[String], - tty: bool, - tls: &TlsOptions, - workspace: &str, -) -> Result<()> { - sandbox_exec_with_mode(server, name, command, tty, tls, false, workspace).await -} - /// What to pack into the tar archive streamed to the sandbox. enum UploadSource { /// A single local file or directory. `tar_name` controls the entry name diff --git a/crates/openshell-cli/tests/sandbox_create_lifecycle_integration.rs b/crates/openshell-cli/tests/sandbox_create_lifecycle_integration.rs index 102cde3714..721ebfd360 100644 --- a/crates/openshell-cli/tests/sandbox_create_lifecycle_integration.rs +++ b/crates/openshell-cli/tests/sandbox_create_lifecycle_integration.rs @@ -1290,6 +1290,45 @@ async fn sandbox_create_sends_cpu_and_memory_limits_only() { assert!(!resources.fields.contains_key("requests")); } +#[tokio::test] +async fn sandbox_create_persists_exact_trailing_argv_as_main_process() { + let server = run_server().await; + let fake_ssh_dir = tempfile::tempdir().unwrap(); + let xdg_dir = tempfile::tempdir().unwrap(); + let _env = test_env(&fake_ssh_dir, &xdg_dir); + let tls = test_tls(&server); + install_fake_ssh(&fake_ssh_dir); + let command = vec![ + "/opt/agent binary".to_string(), + "--prompt=keep spaces".to_string(), + "literal * $HOME".to_string(), + ]; + + run::sandbox_create( + &server.endpoint, + "openshell", + run::SandboxCreateConfig { + name: Some("canonical-main"), + command: &command, + tty_override: Some(false), + ..test_config() + }, + "default", + &tls, + ) + .await + .expect("sandbox create should succeed"); + + let requests = create_requests(&server).await; + let main = requests[0] + .spec + .as_ref() + .and_then(|spec| spec.main_process.as_ref()) + .expect("main process should be persisted at create time"); + assert_eq!(main.command, command); + assert!(!main.terminal); +} + #[tokio::test] async fn sandbox_create_sends_driver_config_json() { let server = run_server().await; diff --git a/crates/openshell-core/src/driver_utils.rs b/crates/openshell-core/src/driver_utils.rs index ae621fde08..8b89002aa0 100644 --- a/crates/openshell-core/src/driver_utils.rs +++ b/crates/openshell-core/src/driver_utils.rs @@ -385,6 +385,7 @@ pub fn build_capabilities_response( driver_name: driver_name.to_string(), driver_version: driver_version.into(), default_image: default_image.into(), + supports_main_process: true, } } diff --git a/crates/openshell-core/src/sandbox_env.rs b/crates/openshell-core/src/sandbox_env.rs index 1549258fa3..751312a339 100644 --- a/crates/openshell-core/src/sandbox_env.rs +++ b/crates/openshell-core/src/sandbox_env.rs @@ -8,6 +8,10 @@ //! supervisor process (which reads them on startup). Using constants here //! prevents typos from producing silently broken sandboxes. +use std::collections::HashMap; + +use serde::{Deserialize, Serialize}; + /// Name of the sandbox (used for policy sync and identification). pub const SANDBOX: &str = "OPENSHELL_SANDBOX"; @@ -26,6 +30,68 @@ pub const LOG_LEVEL: &str = "OPENSHELL_LOG_LEVEL"; /// Shell command to run inside the sandbox. pub const SANDBOX_COMMAND: &str = "OPENSHELL_SANDBOX_COMMAND"; +/// Versioned JSON specification for the exact canonical main process. +pub const MAIN_PROCESS_SPEC: &str = "OPENSHELL_MAIN_PROCESS_SPEC"; + +/// Lossless driver-to-supervisor representation of the canonical process. +#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)] +pub struct MainProcessConfig { + pub version: u32, + pub command: Vec, + pub environment: HashMap, + pub working_directory: String, + pub terminal: bool, +} + +impl MainProcessConfig { + pub const VERSION: u32 = 1; + + #[must_use] + pub fn scratch() -> Self { + Self { + version: Self::VERSION, + command: vec!["/bin/bash".to_string(), "-l".to_string()], + environment: HashMap::new(), + working_directory: String::new(), + terminal: true, + } + } + + #[must_use] + pub fn from_driver_spec(spec: Option<&crate::proto::compute::v1::MainProcessSpec>) -> Self { + spec.map_or_else(Self::scratch, |spec| Self { + version: Self::VERSION, + command: spec.command.clone(), + environment: spec.environment.clone(), + working_directory: spec.working_directory.clone(), + terminal: spec.terminal, + }) + } + + /// Decode the versioned transport without shell interpretation. + pub fn decode(json: &str) -> Result { + let config: Self = serde_json::from_str(json) + .map_err(|error| format!("invalid {MAIN_PROCESS_SPEC}: {error}"))?; + if config.version != Self::VERSION { + return Err(format!( + "unsupported {MAIN_PROCESS_SPEC} version {}", + config.version + )); + } + if config.command.is_empty() || config.command[0].is_empty() { + return Err(format!("{MAIN_PROCESS_SPEC} command must not be empty")); + } + Ok(config) + } + + /// Encode the versioned driver-to-supervisor transport. + pub fn encode_driver_spec( + spec: Option<&crate::proto::compute::v1::MainProcessSpec>, + ) -> Result { + serde_json::to_string(&Self::from_driver_spec(spec)) + } +} + /// Deployment-controlled telemetry toggle propagated to the sandbox supervisor. pub const TELEMETRY_ENABLED: &str = "OPENSHELL_TELEMETRY_ENABLED"; @@ -130,3 +196,33 @@ pub const OCI_IMAGE_USER: &str = "OPENSHELL_OCI_IMAGE_USER"; // environment variables: it travels on the supervisor's argv // (`--upstream-proxy` and friends), which a sandbox image cannot forge the // way it could bake `ENV` values. + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn main_process_transport_preserves_argument_boundaries() { + let spec = crate::proto::compute::v1::MainProcessSpec { + command: vec!["/bin/sh".into(), "-c".into(), "printf '%s' 'a b'".into()], + environment: HashMap::from([("MODE".into(), "a b".into())]), + working_directory: "/sandbox/work".into(), + terminal: false, + }; + let encoded = MainProcessConfig::encode_driver_spec(Some(&spec)).unwrap(); + let decoded = MainProcessConfig::decode(&encoded).unwrap(); + assert_eq!(decoded.command, spec.command); + assert_eq!(decoded.environment, spec.environment); + assert_eq!(decoded.working_directory, spec.working_directory); + assert!(!decoded.terminal); + } + + #[test] + fn main_process_transport_rejects_unknown_version() { + let error = MainProcessConfig::decode( + r#"{"version":2,"command":["/bin/true"],"environment":{},"working_directory":"","terminal":false}"#, + ) + .unwrap_err(); + assert!(error.contains("unsupported")); + } +} diff --git a/crates/openshell-driver-docker/README.md b/crates/openshell-driver-docker/README.md index 48e56de7bc..915dbf90a7 100644 --- a/crates/openshell-driver-docker/README.md +++ b/crates/openshell-driver-docker/README.md @@ -83,7 +83,7 @@ contract: | `network_mode = openshell` | Places the supervisor on the managed Docker bridge network. | | `cap_add` | Grants supervisor-only capabilities required for namespace setup and process inspection. | | `apparmor=unconfined` | Avoids Docker's default profile blocking required mount operations. | -| `restart_policy = unless-stopped` | Keeps managed sandboxes resumable across daemon or gateway restarts. | +| `restart_policy = no` | A canonical main-process exit remains terminal and is not silently restarted by Docker. | | `PidsLimit` | Enforces the sandbox PID budget at the Docker cgroup layer. Set `[openshell.drivers.docker].sandbox_pids_limit = 0` to inherit the Docker/runtime default. | | CDI GPU request | Uses opaque `driver_config.cdi_devices` values when set; otherwise selects the requested count of NVIDIA CDI GPUs in round-robin order when daemon CDI support is detected. Docker daemon `/info` can permit `nvidia.com/gpu=all` as a WSL2 all-only compatibility fallback, where it counts as one selectable device. Exact CDI device lists must not contain duplicates and must match the effective GPU count. | @@ -175,7 +175,7 @@ overwrites security-critical keys: - `OPENSHELL_SANDBOX_ID` - `OPENSHELL_SANDBOX` - `OPENSHELL_SSH_SOCKET_PATH` -- `OPENSHELL_SANDBOX_COMMAND` +- `OPENSHELL_MAIN_PROCESS_SPEC` - TLS path variables when HTTPS is enabled Do not allow sandbox images or templates to override these values. diff --git a/crates/openshell-driver-docker/src/lib.rs b/crates/openshell-driver-docker/src/lib.rs index b1fb5ec224..5e86641551 100644 --- a/crates/openshell-driver-docker/src/lib.rs +++ b/crates/openshell-driver-docker/src/lib.rs @@ -11,7 +11,7 @@ use bollard::models::{ ContainerCreateBody, ContainerState, ContainerStateStatusEnum, ContainerSummary, ContainerSummaryStateEnum, CreateImageInfo, DeviceRequest, EndpointSettings, HostConfig, Mount, MountTmpfsOptions, MountTypeEnum, MountVolumeOptions, NetworkCreateRequest, NetworkingConfig, - ProgressDetail, RestartPolicy, RestartPolicyNameEnum, SystemInfo, + ProgressDetail, SystemInfo, }; use bollard::query_parameters::{ CreateContainerOptionsBuilder, CreateImageOptions, DownloadFromContainerOptionsBuilder, @@ -77,7 +77,6 @@ const TLS_CA_MOUNT_PATH: &str = openshell_core::driver_utils::TLS_CA_MOUNT_PATH; const TLS_CERT_MOUNT_PATH: &str = openshell_core::driver_utils::TLS_CERT_MOUNT_PATH; const TLS_KEY_MOUNT_PATH: &str = openshell_core::driver_utils::TLS_KEY_MOUNT_PATH; const SANDBOX_TOKEN_MOUNT_PATH: &str = openshell_core::driver_utils::SANDBOX_TOKEN_MOUNT_PATH; -const SANDBOX_COMMAND: &str = "sleep infinity"; const SUPERVISOR_PATH: &str = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"; const HOST_OPENSHELL_INTERNAL: &str = "host.openshell.internal"; const HOST_DOCKER_INTERNAL: &str = "host.docker.internal"; @@ -2448,9 +2447,16 @@ fn build_environment_for_oci_user( openshell_core::sandbox_env::SSH_SOCKET_PATH.to_string(), config.ssh_socket_path.clone(), ); + let main_process = openshell_core::sandbox_env::MainProcessConfig::encode_driver_spec( + sandbox + .spec + .as_ref() + .and_then(|spec| spec.main_process.as_ref()), + ) + .expect("main process config serialization cannot fail"); environment.insert( - openshell_core::sandbox_env::SANDBOX_COMMAND.to_string(), - SANDBOX_COMMAND.to_string(), + openshell_core::sandbox_env::MAIN_PROCESS_SPEC.to_string(), + main_process, ); environment.insert( openshell_core::sandbox_env::TELEMETRY_ENABLED.to_string(), @@ -2696,10 +2702,9 @@ fn build_container_create_body_for_image( Some(binds) }, mounts: Some(user_mounts), - restart_policy: Some(RestartPolicy { - name: Some(RestartPolicyNameEnum::UNLESS_STOPPED), - maximum_retry_count: None, - }), + // Canonical main-process exit is terminal. Runtime restart would + // silently create a new process generation behind the gateway. + restart_policy: None, cap_add: Some(vec![ "SYS_ADMIN".to_string(), "NET_ADMIN".to_string(), diff --git a/crates/openshell-driver-docker/src/tests.rs b/crates/openshell-driver-docker/src/tests.rs index eddfd778bd..c1b15252bb 100644 --- a/crates/openshell-driver-docker/src/tests.rs +++ b/crates/openshell-driver-docker/src/tests.rs @@ -45,6 +45,7 @@ fn test_sandbox() -> DriverSandbox { }), resource_requirements: None, sandbox_token: String::new(), + main_process: None, }), status: None, workspace: String::new(), @@ -618,7 +619,17 @@ fn build_environment_sets_docker_tls_paths() { assert!(env.contains(&format!("OPENSHELL_TLS_KEY={TLS_KEY_MOUNT_PATH}"))); assert!(env.contains(&"TEMPLATE_ENV=template".to_string())); assert!(env.contains(&"SPEC_ENV=spec".to_string())); - assert!(env.contains(&"OPENSHELL_SANDBOX_COMMAND=sleep infinity".to_string())); + let encoded = env + .iter() + .find_map(|entry| { + entry + .strip_prefix("OPENSHELL_MAIN_PROCESS_SPEC=") + .map(str::to_string) + }) + .expect("main-process transport"); + let main = openshell_core::sandbox_env::MainProcessConfig::decode(&encoded).unwrap(); + assert_eq!(main.command, vec!["/bin/bash", "-l"]); + assert!(main.terminal); } #[test] diff --git a/crates/openshell-driver-kubernetes/README.md b/crates/openshell-driver-kubernetes/README.md index ec37c4e67a..fac220c83b 100644 --- a/crates/openshell-driver-kubernetes/README.md +++ b/crates/openshell-driver-kubernetes/README.md @@ -93,6 +93,11 @@ bootstrap exchange. The gateway uses the supervisor relay for connect, exec, and file sync. Sandbox pods do not need direct external ingress for SSH. +The driver forwards the canonical main-process specification to the process +supervisor and sets pod `restartPolicy: Never`. Main-process environment +overrides stay local to that child; the sidecar bootstrap retains the unmodified +provider environment used by later exec, editor, and SFTP sessions. + ## Container Security Context The default `combined` supervisor topology grants the sandbox agent container diff --git a/crates/openshell-driver-kubernetes/src/driver.rs b/crates/openshell-driver-kubernetes/src/driver.rs index ddc7fe2a4f..932f15c29e 100644 --- a/crates/openshell-driver-kubernetes/src/driver.rs +++ b/crates/openshell-driver-kubernetes/src/driver.rs @@ -3336,6 +3336,7 @@ fn sandbox_to_k8s_spec( template, driver_gpu_requirements(spec.resource_requirements.as_ref()), &pod_env, + spec.main_process.as_ref(), &driver_config, inject_workspace, params, @@ -3369,6 +3370,7 @@ fn sandbox_to_k8s_spec( &SandboxTemplate::default(), driver_gpu_requirements(spec.and_then(|s| s.resource_requirements.as_ref())), &pod_env, + spec.and_then(|spec| spec.main_process.as_ref()), &driver_config, inject_workspace, params, @@ -3396,6 +3398,7 @@ fn sandbox_template_to_k8s( template, gpu_requirements.as_ref(), spec_environment, + None, &driver_config, inject_workspace, params, @@ -3416,6 +3419,7 @@ fn sandbox_template_to_k8s_with_gpu_requirements( template, gpu_requirements, spec_environment, + None, &driver_config, inject_workspace, params, @@ -3426,6 +3430,7 @@ fn sandbox_template_to_k8s_with_validated_config( template: &SandboxTemplate, gpu_requirements: Option<&GpuResourceRequirements>, spec_environment: &std::collections::HashMap, + main_process: Option<&openshell_core::proto::compute::v1::MainProcessSpec>, driver_config: &KubernetesSandboxDriverConfig, inject_workspace: bool, params: &SandboxPodParams<'_>, @@ -3535,6 +3540,9 @@ fn sandbox_template_to_k8s_with_validated_config( "automountServiceAccountToken".to_string(), serde_json::json!(false), ); + // Do not let kubelet replace the canonical main-process generation after + // the supervisor exits. The gateway records that exit as terminal Error. + spec.insert("restartPolicy".to_string(), serde_json::json!("Never")); let mut container = serde_json::Map::new(); container.insert("name".to_string(), serde_json::json!("agent")); @@ -3559,6 +3567,7 @@ fn sandbox_template_to_k8s_with_validated_config( None, &template.environment, spec_environment, + main_process, params.sandbox_id, params.sandbox_name, params.grpc_endpoint, @@ -3928,6 +3937,7 @@ fn build_env_list( existing_env: Option<&Vec>, template_environment: &std::collections::HashMap, spec_environment: &std::collections::HashMap, + main_process: Option<&openshell_core::proto::compute::v1::MainProcessSpec>, sandbox_id: &str, sandbox_name: &str, grpc_endpoint: &str, @@ -3949,6 +3959,14 @@ fn build_env_list( &json, ); } + let main_process = + openshell_core::sandbox_env::MainProcessConfig::encode_driver_spec(main_process) + .expect("main process config serialization cannot fail"); + upsert_env( + &mut env, + openshell_core::sandbox_env::MAIN_PROCESS_SPEC, + &main_process, + ); apply_required_env( &mut env, sandbox_id, @@ -3984,11 +4002,6 @@ fn apply_required_env( upsert_env(env, openshell_core::sandbox_env::SANDBOX_ID, sandbox_id); upsert_env(env, openshell_core::sandbox_env::SANDBOX, sandbox_name); upsert_env(env, openshell_core::sandbox_env::ENDPOINT, grpc_endpoint); - upsert_env( - env, - openshell_core::sandbox_env::SANDBOX_COMMAND, - "sleep infinity", - ); upsert_env( env, openshell_core::sandbox_env::TELEMETRY_ENABLED, diff --git a/crates/openshell-driver-podman/README.md b/crates/openshell-driver-podman/README.md index 67ba07944e..77c7916728 100644 --- a/crates/openshell-driver-podman/README.md +++ b/crates/openshell-driver-podman/README.md @@ -282,7 +282,7 @@ via sandbox templates: - `OPENSHELL_ENDPOINT` - `OPENSHELL_SSH_SOCKET_PATH` - `OPENSHELL_CONTAINER_IMAGE` -- `OPENSHELL_SANDBOX_COMMAND` +- `OPENSHELL_MAIN_PROCESS_SPEC` ## Sandbox Lifecycle diff --git a/crates/openshell-driver-podman/src/container.rs b/crates/openshell-driver-podman/src/container.rs index cae477618c..6ee822f2f6 100644 --- a/crates/openshell-driver-podman/src/container.rs +++ b/crates/openshell-driver-podman/src/container.rs @@ -516,9 +516,13 @@ fn build_env( config.sandbox_ssh_socket_path.clone(), ); env.insert("OPENSHELL_CONTAINER_IMAGE".into(), image.to_string()); + let main_process = openshell_core::sandbox_env::MainProcessConfig::encode_driver_spec( + spec.and_then(|spec| spec.main_process.as_ref()), + ) + .expect("main process config serialization cannot fail"); env.insert( - openshell_core::sandbox_env::SANDBOX_COMMAND.into(), - "sleep infinity".into(), + openshell_core::sandbox_env::MAIN_PROCESS_SPEC.into(), + main_process, ); env.insert( openshell_core::sandbox_env::TELEMETRY_ENABLED.into(), diff --git a/crates/openshell-driver-vm/README.md b/crates/openshell-driver-vm/README.md index 10ffac2ba1..c906b3b074 100644 --- a/crates/openshell-driver-vm/README.md +++ b/crates/openshell-driver-vm/README.md @@ -206,6 +206,10 @@ marked sandboxes without launching compute. Start removes the marker and uses the normal persisted restore path with the existing overlay. Delete removes the entire sandbox state directory, including a stop marker and overlay. +The driver records a terminal tombstone when the canonical main process exits. +Driver startup reports that sandbox as terminal instead of relaunching the VM, +even when the process exited successfully. + ## Logs and debugging Raise log verbosity for both processes: diff --git a/crates/openshell-driver-vm/src/driver.rs b/crates/openshell-driver-vm/src/driver.rs index 4dd2ea059b..31d1a465b2 100644 --- a/crates/openshell-driver-vm/src/driver.rs +++ b/crates/openshell-driver-vm/src/driver.rs @@ -169,6 +169,9 @@ const OVERLAY_TEMPLATE_CACHE_LAYOUT_VERSION: &str = "sandbox-overlay-ext4-v1"; const SANDBOX_OVERLAY_IMAGE: &str = "overlay.ext4"; const SANDBOX_REQUEST_FILE: &str = "sandbox.pb"; const SANDBOX_STOPPED_FILE: &str = "stopped"; +/// Durable tombstone preventing driver restart from relaunching a sandbox +/// whose canonical main process already terminated. +const MAIN_PROCESS_EXITED_FILE: &str = "main-process-exited"; const GUEST_IMAGE_CONFIG_DIR: &str = "openshell-image"; const GUEST_IMAGE_OCI_LAYOUT_DIR: &str = "oci"; const GUEST_IMAGE_OCI_REF: &str = "openshell"; @@ -520,6 +523,7 @@ impl VmDriver { driver_name: DRIVER_NAME.to_string(), driver_version: openshell_core::VERSION.to_string(), default_image: self.config.default_image.clone(), + supports_main_process: true, } } @@ -1411,6 +1415,37 @@ impl VmDriver { continue; } + if tokio::fs::try_exists(state_dir.join(MAIN_PROCESS_EXITED_FILE)) + .await + .unwrap_or(false) + { + let snapshot = sandbox_snapshot( + &sandbox, + error_condition( + "ProcessExited", + "Canonical main process exited before VM driver restart", + ), + false, + ); + let mut registry = self.registry.lock().await; + registry.entry(sandbox.id.clone()).or_insert(SandboxRecord { + snapshot: snapshot.clone(), + state_dir: state_dir.clone(), + process: None, + provisioning_task: None, + gpu_bdf: None, + qemu_network_allocated: false, + deleting: false, + }); + drop(registry); + self.publish_snapshot(snapshot); + info!( + sandbox_id = %sandbox.id, + "vm driver: preserved terminal sandbox without restarting canonical process" + ); + continue; + } + self.restore_persisted_sandbox(sandbox, state_dir, false, &tracing::Span::current()) .await; } @@ -3164,6 +3199,25 @@ impl VmDriver { }; if let Some(status) = exit_status { + let state_dir = { + let registry = self.registry.lock().await; + registry + .get(&sandbox_id) + .map(|record| record.state_dir.clone()) + }; + if let Some(state_dir) = state_dir + && let Err(error) = write_private_file( + &state_dir.join(MAIN_PROCESS_EXITED_FILE), + b"terminal\n".to_vec(), + ) + .await + { + warn!( + sandbox_id = %sandbox_id, + %error, + "vm driver: failed to persist canonical-process exit tombstone" + ); + } let message = status.code().map_or_else( || "VM process exited".to_string(), |code| format!("VM process exited with status {code}"), @@ -4435,9 +4489,16 @@ fn build_guest_environment( openshell_core::sandbox_env::SSH_SOCKET_PATH.to_string(), GUEST_SSH_SOCKET_PATH.to_string(), ); + let main_process = openshell_core::sandbox_env::MainProcessConfig::encode_driver_spec( + sandbox + .spec + .as_ref() + .and_then(|spec| spec.main_process.as_ref()), + ) + .expect("main process config serialization cannot fail"); environment.insert( - openshell_core::sandbox_env::SANDBOX_COMMAND.to_string(), - "tail -f /dev/null".to_string(), + openshell_core::sandbox_env::MAIN_PROCESS_SPEC.to_string(), + main_process, ); environment.insert( openshell_core::sandbox_env::LOG_LEVEL.to_string(), @@ -5909,6 +5970,45 @@ mod tests { } } + #[tokio::test] + async fn startup_does_not_restore_terminal_canonical_process() { + let temp = tempfile::tempdir().unwrap(); + let mut driver = test_driver_with_extensions(LifecycleExtensionRegistry::new()); + driver.config.state_dir = temp.path().to_path_buf(); + let sandbox = Sandbox { + id: "sb-terminal-main".to_string(), + name: "terminal-main".to_string(), + spec: Some(SandboxSpec { + template: Some(SandboxTemplate { + image: "unused-image".to_string(), + ..Default::default() + }), + ..Default::default() + }), + ..Default::default() + }; + let state_dir = temp.path().join("sandboxes").join(&sandbox.id); + tokio::fs::create_dir_all(&state_dir).await.unwrap(); + write_sandbox_request(&state_dir, &sandbox).await.unwrap(); + write_private_file( + &state_dir.join(MAIN_PROCESS_EXITED_FILE), + b"terminal\n".to_vec(), + ) + .await + .unwrap(); + + driver.restore_persisted_sandboxes().await; + + let registry = driver.registry.lock().await; + let record = registry.get(&sandbox.id).expect("terminal record"); + assert!(record.process.is_none()); + assert!(record.provisioning_task.is_none()); + let status = record.snapshot.status.as_ref().expect("terminal status"); + assert!(status.conditions.iter().any(|condition| { + condition.reason == "ProcessExited" && condition.status == "False" + })); + } + #[tokio::test] async fn background_provisioning_does_not_extend_the_rpc_span_lifetime() { let traced = TestTracing::new(); diff --git a/crates/openshell-sandbox/Cargo.toml b/crates/openshell-sandbox/Cargo.toml index 70603524a8..c653db84dd 100644 --- a/crates/openshell-sandbox/Cargo.toml +++ b/crates/openshell-sandbox/Cargo.toml @@ -50,6 +50,7 @@ prost = { workspace = true } # Logging tracing = { workspace = true } +uuid = { workspace = true } tracing-subscriber = { workspace = true } tracing-appender = { workspace = true } diff --git a/crates/openshell-sandbox/src/lib.rs b/crates/openshell-sandbox/src/lib.rs index c1dbada149..537097ce67 100644 --- a/crates/openshell-sandbox/src/lib.rs +++ b/crates/openshell-sandbox/src/lib.rs @@ -83,14 +83,17 @@ const SIDECAR_READY_TIMEOUT_SECS: u64 = 120; /// Returns an error if the command fails to start or encounters a fatal error. #[allow( clippy::too_many_arguments, + clippy::implicit_hasher, clippy::similar_names, clippy::fn_params_excessive_bools )] pub async fn run_sandbox( command: Vec, workdir: Option, + main_workdir: Option, timeout_secs: u64, interactive: bool, + main_environment: std::collections::HashMap, sandbox_id: Option, sandbox: Option, openshell_endpoint: Option, @@ -340,6 +343,10 @@ pub async fn run_sandbox( report_credential_gating_unavailable(); } + // Canonical-process overrides are deliberately applied only to the main + // child. Keep the provider snapshot pristine because Kubernetes forwards + // it to the process sidecar for later exec/editor/SFTP children. + // Shared agent-proposals feature flag. Seed from the same initial settings // snapshot that produced the policy so networking and process setup agree // before the poll loop starts reconciling later changes. @@ -348,6 +355,7 @@ pub async fn run_sandbox( let process_control_writer = process_control_connection .as_ref() .map(|connection| connection.writer.clone()); + let process_exit_ack = Arc::new(tokio::sync::Mutex::new(None)); let mut process_control_closed = None; if let Some(connection) = process_control_connection { process_control_closed = Some(connection.closed); @@ -355,6 +363,7 @@ pub async fn run_sandbox( connection.updates, provider_credentials.clone(), agent_proposals.clone(), + Arc::clone(&process_exit_ack), ); } @@ -505,12 +514,15 @@ pub async fn run_sandbox( sidecar_control_task = Some(connection_task); spawn_sidecar_entrypoint_handler( entrypoint_rx, - entrypoint_pid.clone(), - opa_engine.clone(), - retained_proto.clone(), - openshell_endpoint.clone(), - sandbox_id.clone(), - std::path::PathBuf::from(trusted_ssh_socket_path), + SidecarEntrypointHandler { + entrypoint_pid: entrypoint_pid.clone(), + opa_engine: opa_engine.clone(), + retained_proto: retained_proto.clone(), + openshell_endpoint: openshell_endpoint.clone(), + sandbox_id: sandbox_id.clone(), + trusted_ssh_socket_path: std::path::PathBuf::from(trusted_ssh_socket_path), + control_publisher: sidecar_control_publisher.clone(), + }, ); } @@ -704,6 +716,8 @@ pub async fn run_sandbox( } let process_policy = process_policy_for_topology(&policy, sidecar_network_enforcement)?; + let mut main_env = provider_env.clone(); + main_env.extend(main_environment); let sidecar_bootstrap_ca_file_paths = sidecar_bootstrap.as_ref().and_then(|bootstrap| { bootstrap .proxy_ca_cert_path @@ -725,21 +739,47 @@ pub async fn run_sandbox( } }); - let entrypoint_started_tx = + let entrypoint_started_tx = if process_uses_sidecar_control + && let Some(writer) = process_control_writer.clone() + { + let (tx, rx) = tokio::sync::oneshot::channel(); + tokio::spawn(async move { + match rx.await { + Ok((pid, generation)) => { + if let Err(err) = + sidecar_control::send_entrypoint_started(&writer, pid, generation).await + { + warn!(error = %err, "Failed to send sidecar entrypoint event"); + } + } + Err(_closed) => { + debug!("Entrypoint exited before sidecar entrypoint event was sent"); + } + } + }); + Some(tx) + } else { + None + }; + let sidecar_exit_tx = if process_uses_sidecar_control && let Some(writer) = process_control_writer.clone() { - let (tx, rx) = tokio::sync::oneshot::channel(); + let exit_ack = Arc::clone(&process_exit_ack); + let (tx, mut rx) = tokio::sync::mpsc::channel::< + openshell_supervisor_process::run::SidecarExitReport, + >(1); tokio::spawn(async move { - match rx.await { - Ok(pid) => { - if let Err(err) = - sidecar_control::send_entrypoint_started(&writer, pid).await - { - warn!(error = %err, "Failed to send sidecar entrypoint event"); - } - } - Err(_closed) => { - debug!("Entrypoint exited before sidecar entrypoint event was sent"); - } + while let Some((exit, ack)) = rx.recv().await { + let generation = exit.generation.clone(); + let (durable_tx, durable_rx) = tokio::sync::oneshot::channel(); + *exit_ack.lock().await = Some((generation, durable_tx)); + let result = + match sidecar_control::send_main_process_exited(&writer, exit).await { + Ok(()) => durable_rx.await.map_err(|_| { + "sidecar durable exit acknowledgement closed".to_string() + }), + Err(error) => Err(error.to_string()), + }; + let _ = ack.send(result); } }); Some(tx) @@ -751,6 +791,7 @@ pub async fn run_sandbox( program, args, workspace, + main_workdir, timeout_secs, interactive, sandbox_id.as_deref(), @@ -762,8 +803,9 @@ pub async fn run_sandbox( process_enforcement_mode, entrypoint_pid, entrypoint_started_tx, + sidecar_exit_tx, provider_credentials, - provider_env, + main_env, ca_file_paths, agent_proposals.clone(), #[cfg(target_os = "linux")] @@ -908,6 +950,9 @@ type LoadedPolicyBundle = ( LoadedPolicyOrigin, ); +type MainProcessExitAckWaiter = + Arc)>>>; + fn load_policy_from_sidecar_bootstrap( bootstrap: &sidecar_control::BootstrapData, ) -> Result { @@ -930,6 +975,7 @@ fn spawn_sidecar_control_update_watcher( mut updates: tokio::sync::mpsc::UnboundedReceiver, provider_credentials: ProviderCredentialState, agent_proposals: AgentProposals, + exit_ack: MainProcessExitAckWaiter, ) -> tokio::task::JoinHandle<()> { tokio::spawn(async move { while let Some(update) = updates.recv().await { @@ -980,26 +1026,80 @@ fn spawn_sidecar_control_update_watcher( skills::install_static_skills, ); } + sidecar_control::ControlUpdate::MainProcessExitAck { generation } => { + let mut waiter = exit_ack.lock().await; + if waiter + .as_ref() + .is_some_and(|(expected, _)| expected == &generation) + && let Some((_, ack)) = waiter.take() + { + let _ = ack.send(()); + } + } } } }) } #[cfg(target_os = "linux")] -fn spawn_sidecar_entrypoint_handler( - mut entrypoint_rx: tokio::sync::mpsc::Receiver, +struct SidecarEntrypointHandler { entrypoint_pid: Arc, opa_engine: Option>, retained_proto: Option, openshell_endpoint: Option, sandbox_id: Option, trusted_ssh_socket_path: std::path::PathBuf, + control_publisher: Option, +} + +#[cfg(target_os = "linux")] +fn spawn_sidecar_entrypoint_handler( + mut entrypoint_rx: tokio::sync::mpsc::Receiver, + handler: SidecarEntrypointHandler, ) { tokio::spawn(async move { + let SidecarEntrypointHandler { + entrypoint_pid, + opa_engine, + retained_proto, + openshell_endpoint, + sandbox_id, + trusted_ssh_socket_path, + control_publisher, + } = handler; let mut session_started = false; let mut trusted_supervisor_pid = None; let terminating = Arc::new(AtomicBool::new(false)); while let Some(started) = entrypoint_rx.recv().await { + if let Some(exit) = started.exit { + terminating.store(true, Ordering::Release); + if let (Some(endpoint), Some(id)) = + (openshell_endpoint.as_ref(), sandbox_id.as_ref()) + { + let mut delay = Duration::from_millis(250); + loop { + match openshell_supervisor_process::supervisor_session::report_main_process_exit( + endpoint, + id, + &exit.generation, + exit.clone(), + ) + .await + { + Ok(()) => break, + Err(error) => { + warn!(%error, "sidecar main-process exit report failed; retrying"); + tokio::time::sleep(delay).await; + delay = (delay * 2).min(Duration::from_secs(2)); + } + } + } + if let Some(publisher) = control_publisher.as_ref() { + publisher.publish_main_process_exit_ack(exit.generation.clone()); + } + } + break; + } entrypoint_pid.store(started.pid, Ordering::Release); if started.start_session { info!( @@ -1048,6 +1148,7 @@ fn spawn_sidecar_entrypoint_handler( None, Some(supervisor_pid), Arc::clone(&terminating), + started.generation.clone(), ); session_started = true; info!("sidecar supervisor session task spawned"); @@ -4047,6 +4148,7 @@ mod tests { rx, provider_credentials.clone(), AgentProposals::default(), + Arc::new(tokio::sync::Mutex::new(None)), ); tx.send(sidecar_control::ControlUpdate::ProviderEnv { @@ -4101,8 +4203,12 @@ mod tests { let provider_credentials = ProviderCredentialState::from_child_env_snapshot(0, std::collections::HashMap::new()); let agent_proposals = AgentProposals::new(true); - let handle = - spawn_sidecar_control_update_watcher(rx, provider_credentials, agent_proposals.clone()); + let handle = spawn_sidecar_control_update_watcher( + rx, + provider_credentials, + agent_proposals.clone(), + Arc::new(tokio::sync::Mutex::new(None)), + ); tx.send(sidecar_control::ControlUpdate::AgentProposals { enabled: false, diff --git a/crates/openshell-sandbox/src/main.rs b/crates/openshell-sandbox/src/main.rs index 98af7f9ea9..cb4bf802be 100644 --- a/crates/openshell-sandbox/src/main.rs +++ b/crates/openshell-sandbox/src/main.rs @@ -643,14 +643,41 @@ fn main() -> Result<()> { (None, None) }; - // Get command - either from CLI args, environment variable, or default to /bin/bash - let command = if !args.command.is_empty() { - args.command + // Resolve an exact canonical process. Explicit offline/test argv wins; + // drivers otherwise provide a versioned JSON transport so argument + // boundaries are never reconstructed with shell parsing. + let policy_workdir = args.workdir.clone(); + let (command, main_workdir, interactive, main_environment) = if !args.command.is_empty() { + ( + args.command, + policy_workdir.clone(), + args.interactive, + std::collections::HashMap::default(), + ) + } else if let Ok(json) = std::env::var(openshell_core::sandbox_env::MAIN_PROCESS_SPEC) { + let config = openshell_core::sandbox_env::MainProcessConfig::decode(&json) + .map_err(|error| miette::miette!("{error}"))?; + let workdir = if config.working_directory.is_empty() { + policy_workdir.clone() + } else { + Some(config.working_directory) + }; + (config.command, workdir, config.terminal, config.environment) } else if let Ok(c) = std::env::var(openshell_core::sandbox_env::SANDBOX_COMMAND) { - // Simple shell-like splitting on whitespace - c.split_whitespace().map(String::from).collect() + ( + c.split_whitespace().map(String::from).collect(), + policy_workdir.clone(), + args.interactive, + std::collections::HashMap::default(), + ) } else { - vec!["/bin/bash".to_string()] + let config = openshell_core::sandbox_env::MainProcessConfig::scratch(); + ( + config.command, + policy_workdir.clone(), + config.terminal, + config.environment, + ) }; info!(command = ?command, "Starting sandbox"); @@ -668,9 +695,11 @@ fn main() -> Result<()> { run_sandbox( command, - args.workdir, + policy_workdir, + main_workdir, args.timeout, - args.interactive, + interactive, + main_environment, args.sandbox_id, args.sandbox, args.openshell_endpoint, diff --git a/crates/openshell-sandbox/src/sidecar_control.rs b/crates/openshell-sandbox/src/sidecar_control.rs index 8cc2854e41..e01ab5295b 100644 --- a/crates/openshell-sandbox/src/sidecar_control.rs +++ b/crates/openshell-sandbox/src/sidecar_control.rs @@ -35,6 +35,8 @@ pub struct BootstrapData { pub struct EntrypointStarted { pub pid: u32, pub start_session: bool, + pub generation: String, + pub exit: Option, } #[derive(Debug, Clone, Copy)] @@ -58,6 +60,9 @@ pub enum ControlUpdate { enabled: bool, config_revision: u64, }, + MainProcessExitAck { + generation: String, + }, } #[derive(Clone)] @@ -115,6 +120,12 @@ impl Publisher { config_revision, }); } + + pub fn publish_main_process_exit_ack(&self, generation: String) { + let _ = self + .updates + .send(WireServerMessage::MainProcessExitAck { generation }); + } } pub struct ServerHandle { @@ -154,8 +165,20 @@ pub struct ProcessConnection { #[derive(Debug, Serialize, Deserialize)] #[serde(tag = "type", rename_all = "snake_case")] enum WireClientMessage { - BootstrapRequest { supervisor_pid: u32 }, - EntrypointStarted { pid: u32 }, + BootstrapRequest { + supervisor_pid: u32, + }, + EntrypointStarted { + pid: u32, + generation: String, + }, + MainProcessExited { + generation: String, + exit_code: Option, + signal: Option, + started_at_ms: i64, + finished_at_ms: i64, + }, } #[derive(Debug, Clone, Serialize, Deserialize)] @@ -182,6 +205,9 @@ enum WireServerMessage { enabled: bool, config_revision: u64, }, + MainProcessExitAck { + generation: String, + }, } impl BootstrapData { @@ -271,6 +297,9 @@ impl TryFrom for ControlUpdate { enabled, config_revision, }), + WireServerMessage::MainProcessExitAck { generation } => { + Ok(Self::MainProcessExitAck { generation }) + } WireServerMessage::BootstrapResponse { .. } => Err(miette::miette!( "unexpected sidecar bootstrap response after initial handshake" )), @@ -431,11 +460,14 @@ async fn handle_connection( .send(EntrypointStarted { pid: supervisor_pid, start_session: false, + generation: String::new(), + exit: None, }) .await .map_err(|_| miette::miette!("sidecar entrypoint receiver closed"))?; } - WireClientMessage::EntrypointStarted { .. } => { + WireClientMessage::EntrypointStarted { .. } + | WireClientMessage::MainProcessExited { .. } => { return Err(miette::miette!( "sidecar control client sent entrypoint event before bootstrap" )); @@ -462,7 +494,7 @@ async fn handle_connection( WireClientMessage::BootstrapRequest { .. } => { debug!("Ignoring duplicate sidecar bootstrap request"); } - WireClientMessage::EntrypointStarted { pid } => { + WireClientMessage::EntrypointStarted { pid, generation } => { if pid == 0 { warn!("Ignoring sidecar entrypoint event with pid=0"); continue; @@ -471,6 +503,31 @@ async fn handle_connection( .send(EntrypointStarted { pid, start_session: true, + generation, + exit: None, + }) + .await + .map_err(|_| miette::miette!("sidecar entrypoint receiver closed"))?; + } + WireClientMessage::MainProcessExited { + generation, + exit_code, + signal, + started_at_ms, + finished_at_ms, + } => { + entrypoint_tx + .send(EntrypointStarted { + pid: 0, + start_session: false, + generation: generation.clone(), + exit: Some(openshell_core::proto::MainProcessExit { + generation, + exit_code, + signal, + started_at_ms, + finished_at_ms, + }), }) .await .map_err(|_| miette::miette!("sidecar entrypoint receiver closed"))?; @@ -565,8 +622,27 @@ async fn connect_with_retry(path: &Path, timeout: Duration) -> Result>, pid: u32) -> Result<()> { - let message = WireClientMessage::EntrypointStarted { pid }; +pub async fn send_entrypoint_started( + writer: &Arc>, + pid: u32, + generation: String, +) -> Result<()> { + let message = WireClientMessage::EntrypointStarted { pid, generation }; + let mut writer = writer.lock().await; + write_json_line(&mut *writer, &message).await +} + +pub async fn send_main_process_exited( + writer: &Arc>, + exit: openshell_core::proto::MainProcessExit, +) -> Result<()> { + let message = WireClientMessage::MainProcessExited { + generation: exit.generation, + exit_code: exit.exit_code, + signal: exit.signal, + started_at_ms: exit.started_at_ms, + finished_at_ms: exit.finished_at_ms, + }; let mut writer = writer.lock().await; write_json_line(&mut *writer, &message).await } @@ -702,8 +778,9 @@ mod tests { current_peer(), ) .unwrap(); + let publisher = server.publisher(); let mut entrypoint_rx = server.into_entrypoint_receiver(); - let (_bootstrap, connection) = connect_process_client(&socket, Duration::from_secs(1)) + let (_bootstrap, mut connection) = connect_process_client(&socket, Duration::from_secs(1)) .await .unwrap(); @@ -714,7 +791,7 @@ mod tests { assert_eq!(anchor.pid, std::process::id()); assert!(!anchor.start_session); - send_entrypoint_started(&connection.writer, 4242) + send_entrypoint_started(&connection.writer, 4242, "generation-1".to_string()) .await .unwrap(); @@ -724,6 +801,42 @@ mod tests { .unwrap(); assert_eq!(started.pid, 4242); assert!(started.start_session); + assert_eq!(started.generation, "generation-1"); + assert!(started.exit.is_none()); + + send_main_process_exited( + &connection.writer, + openshell_core::proto::MainProcessExit { + generation: "generation-1".to_string(), + exit_code: Some(0), + signal: None, + started_at_ms: 10, + finished_at_ms: 20, + }, + ) + .await + .unwrap(); + let terminal = tokio::time::timeout(Duration::from_secs(1), entrypoint_rx.recv()) + .await + .unwrap() + .unwrap(); + assert_eq!(terminal.exit.unwrap().exit_code, Some(0)); + + assert!( + tokio::time::timeout(Duration::from_millis(20), connection.updates.recv()) + .await + .is_err(), + "process side must not observe a durable ACK before gateway persistence" + ); + publisher.publish_main_process_exit_ack("generation-1".to_string()); + let ack = tokio::time::timeout(Duration::from_secs(1), connection.updates.recv()) + .await + .unwrap() + .unwrap(); + assert!(matches!( + ack, + ControlUpdate::MainProcessExitAck { generation } if generation == "generation-1" + )); } #[tokio::test] diff --git a/crates/openshell-sdk/src/client.rs b/crates/openshell-sdk/src/client.rs index c67e91e219..4c1920aab5 100644 --- a/crates/openshell-sdk/src/client.rs +++ b/crates/openshell-sdk/src/client.rs @@ -799,6 +799,7 @@ fn create_sandbox_request(spec: SandboxSpec) -> proto::CreateSandboxRequest { environment, providers, gpu, + main_process, } = spec; let template = image.map(|image| proto::SandboxTemplate { image, @@ -813,6 +814,12 @@ fn create_sandbox_request(spec: SandboxSpec) -> proto::CreateSandboxRequest { template, providers, resource_requirements, + main_process: main_process.map(|main| proto::MainProcessSpec { + command: main.command, + environment: main.environment, + working_directory: main.working_directory.unwrap_or_default(), + terminal: main.terminal, + }), ..proto::SandboxSpec::default() }), name: name.unwrap_or_default(), @@ -992,4 +999,29 @@ mod tests { let current = slot.read().unwrap().clone().unwrap(); assert_eq!(current.to_str().unwrap(), "Bearer good-token"); } + + #[test] + fn create_request_preserves_canonical_main_process() { + let request = create_sandbox_request(SandboxSpec { + main_process: Some(crate::types::MainProcessSpec { + command: vec!["/opt/agent binary".into(), "--serve exactly".into()], + environment: HashMap::from([("MODE".into(), "worker".into())]), + working_directory: Some("/sandbox/app".into()), + terminal: false, + }), + ..SandboxSpec::default() + }); + + let main = request + .spec + .and_then(|spec| spec.main_process) + .expect("main process should be present"); + assert_eq!(main.command, ["/opt/agent binary", "--serve exactly"]); + assert_eq!( + main.environment.get("MODE").map(String::as_str), + Some("worker") + ); + assert_eq!(main.working_directory, "/sandbox/app"); + assert!(!main.terminal); + } } diff --git a/crates/openshell-sdk/src/lib.rs b/crates/openshell-sdk/src/lib.rs index dbf2524a2a..005b8b7efe 100644 --- a/crates/openshell-sdk/src/lib.rs +++ b/crates/openshell-sdk/src/lib.rs @@ -46,6 +46,6 @@ pub use config::{AuthConfig, ClientConfig}; pub use error::SdkError; pub use refresh::{Refresh, RefreshError, RefreshedToken, TokenSource}; pub use types::{ - ExecOptions, ExecResult, Health, ListOptions, SandboxPhase, SandboxRef, SandboxSpec, - ServiceStatus, WorkspaceRef, + ExecOptions, ExecResult, Health, ListOptions, MainProcessSpec, MainProcessStatus, SandboxPhase, + SandboxRef, SandboxSpec, ServiceStatus, WorkspaceRef, }; diff --git a/crates/openshell-sdk/src/types.rs b/crates/openshell-sdk/src/types.rs index 6f179499c9..acd1f74f7a 100644 --- a/crates/openshell-sdk/src/types.rs +++ b/crates/openshell-sdk/src/types.rs @@ -109,6 +109,28 @@ pub struct SandboxSpec { /// Request a GPU. Driver-specific device selection is configured via /// driver config on the raw proto surface (see [`crate::raw`]). pub gpu: bool, + /// Exact canonical process. `None` selects the gateway's scratch login shell. + pub main_process: Option, +} + +/// Shell-free canonical main-process configuration. +#[derive(Clone, Debug)] +pub struct MainProcessSpec { + pub command: Vec, + pub environment: HashMap, + pub working_directory: Option, + pub terminal: bool, +} + +/// Last observed canonical-process generation and result. +#[derive(Clone, Debug)] +pub struct MainProcessStatus { + pub state: i32, + pub generation: String, + pub exit_code: Option, + pub signal: Option, + pub started_at_ms: i64, + pub finished_at_ms: i64, } /// Reference to a sandbox owned by the gateway. @@ -121,11 +143,24 @@ pub struct SandboxRef { pub phase: SandboxPhase, pub labels: HashMap, pub resource_version: u64, + pub main_process: Option, } impl SandboxRef { pub(crate) fn from_proto(sandbox: proto::Sandbox) -> Self { let phase = sandbox.phase().into(); + let main_process = sandbox + .status + .as_ref() + .and_then(|status| status.main_process.as_ref()) + .map(|main| MainProcessStatus { + state: main.state, + generation: main.generation.clone(), + exit_code: main.exit_code, + signal: main.signal, + started_at_ms: main.started_at_ms, + finished_at_ms: main.finished_at_ms, + }); let meta = sandbox.metadata.unwrap_or_default(); Self { id: meta.id, @@ -134,6 +169,7 @@ impl SandboxRef { phase, labels: meta.labels, resource_version: meta.resource_version, + main_process, } } } diff --git a/crates/openshell-server/src/compute/mod.rs b/crates/openshell-server/src/compute/mod.rs index e09b63de09..5d2532d277 100644 --- a/crates/openshell-server/src/compute/mod.rs +++ b/crates/openshell-server/src/compute/mod.rs @@ -45,8 +45,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, + MainProcessExit, MainProcessState, MainProcessStatus, PlatformEvent, Sandbox, SandboxCondition, + SandboxPhase, SandboxSpec, SandboxStatus, SandboxTemplate, ServiceEndpoint, SshSession, }; use openshell_core::{ObjectLabels, ObjectWorkspace}; #[cfg(not(target_os = "windows"))] @@ -274,6 +274,8 @@ pub struct ComputeDriverInfoSnapshot { pub driver_name: String, /// Driver-reported implementation version from the startup capability snapshot. pub driver_version: String, + /// Whether the driver forwards canonical main-process specifications. + pub supports_main_process: bool, } #[tonic::async_trait] @@ -594,6 +596,7 @@ pub struct ComputeRuntime { startup_starter: Option>, driver_process: Option>, default_image: String, + supports_main_process: bool, store: Arc, sandbox_index: SandboxIndex, sandbox_watch_bus: SandboxWatchBus, @@ -653,8 +656,10 @@ impl ComputeRuntime { name: driver_name.clone(), driver_name: capabilities.driver_name, driver_version: capabilities.driver_version, + supports_main_process: capabilities.supports_main_process, }; let default_image = capabilities.default_image; + let supports_main_process = capabilities.supports_main_process; let gateway_listener_requirements = match driver .get_gateway_listener_requirements(Request::new( GetGatewayListenerRequirementsRequest {}, @@ -715,6 +720,7 @@ impl ComputeRuntime { startup_starter, driver_process, default_image, + supports_main_process, store, sandbox_index, sandbox_watch_bus, @@ -923,6 +929,18 @@ impl ComputeRuntime { } pub async fn validate_sandbox_create(&self, sandbox: &Sandbox) -> Result<(), Status> { + if sandbox + .spec + .as_ref() + .and_then(|spec| spec.main_process.as_ref()) + .is_some() + && !self.supports_main_process + { + return Err(Status::failed_precondition(format!( + "compute driver '{}' does not support canonical main processes; upgrade the driver before creating sandboxes", + self.driver_info.name + ))); + } let driver_sandbox = driver_sandbox_from_public(sandbox, &self.driver_info.name) .map_err(|status| *status)?; self.driver @@ -2699,18 +2717,25 @@ impl ComputeRuntime { Ok(()) } - pub async fn supervisor_session_connected(&self, sandbox_id: &str) -> Result<(), String> { - self.set_supervisor_session_state(sandbox_id, true).await + pub async fn supervisor_session_connected( + &self, + sandbox_id: &str, + generation: &str, + ) -> Result<(), String> { + self.set_supervisor_session_state(sandbox_id, true, Some(generation)) + .await } pub async fn supervisor_session_disconnected(&self, sandbox_id: &str) -> Result<(), String> { - self.set_supervisor_session_state(sandbox_id, false).await + self.set_supervisor_session_state(sandbox_id, false, None) + .await } async fn set_supervisor_session_state( &self, sandbox_id: &str, connected: bool, + generation: Option<&str>, ) -> Result<(), String> { let _guard = self.sync_lock.lock().await; @@ -2745,6 +2770,13 @@ impl ComputeRuntime { let sandbox_name = sandbox.object_name().to_string(); if connected { ensure_supervisor_ready_status(&mut sandbox.status, &sandbox_name); + let status = sandbox.status.get_or_insert_with(Default::default); + status.main_process = Some(MainProcessStatus { + state: MainProcessState::Running as i32, + generation: generation.unwrap_or_default().to_string(), + started_at_ms: crate::persistence::current_time_ms(), + ..Default::default() + }); sandbox.set_phase(SandboxPhase::Ready as i32); } else { ensure_supervisor_not_ready_status(&mut sandbox.status, &sandbox_name); @@ -2778,6 +2810,74 @@ impl ComputeRuntime { Ok(()) } + /// Persist a terminal canonical-process result. Exit code zero is still a + /// sandbox error because the canonical process defines sandbox health. + pub async fn main_process_exited( + &self, + sandbox_id: &str, + exit: &MainProcessExit, + ) -> Result<(), String> { + let _guard = self.sync_lock.lock().await; + let Some(existing) = self + .store + .get_message::(sandbox_id) + .await + .map_err(|error| error.to_string())? + else { + return Ok(()); + }; + let phase = SandboxPhase::try_from(existing.phase()).unwrap_or(SandboxPhase::Unknown); + if matches!( + phase, + SandboxPhase::Deleting | SandboxPhase::Stopping | SandboxPhase::Stopped + ) { + return Ok(()); + } + let current = existing + .status + .as_ref() + .and_then(|status| status.main_process.as_ref()); + if let Some(current) = current { + if current.generation != exit.generation { + return Err(format!( + "stale main-process exit generation '{}' (active generation is '{}')", + exit.generation, current.generation + )); + } + if MainProcessState::try_from(current.state).unwrap_or(MainProcessState::Unspecified) + == MainProcessState::Exited + { + let current_has_precise_result = + current.exit_code.is_some() || current.signal.is_some(); + let incoming_has_precise_result = exit.exit_code.is_some() || exit.signal.is_some(); + if !current_has_precise_result && incoming_has_precise_result { + // A terminal driver snapshot can beat the supervisor report + // and record only that the process exited. Let the durable + // supervisor report enrich that fallback with the exact + // result instead of treating it as a duplicate. + } else if current.exit_code == exit.exit_code && current.signal == exit.signal { + return Ok(()); + } else { + return Err(format!( + "conflicting main-process exit result for generation '{}'", + exit.generation + )); + } + } + } + let expected_resource_version = sandbox_resource_version(&existing); + let sandbox = self + .store + .update_message_cas::(sandbox_id, expected_resource_version, |sandbox| { + apply_main_process_exit(sandbox, exit); + }) + .await + .map_err(|error| error.to_string())?; + self.sandbox_index.update_from_sandbox(&sandbox); + self.sandbox_watch_bus.notify(sandbox_id); + Ok(()) + } + async fn apply_deleted(&self, sandbox_id: &str) -> Result<(), String> { let _guard = self.sync_lock.lock().await; self.apply_deleted_locked(sandbox_id).await @@ -3132,6 +3232,34 @@ impl ComputeRuntime { } } +fn apply_main_process_exit(sandbox: &mut Sandbox, exit: &MainProcessExit) { + let sandbox_name = sandbox.object_name().to_string(); + let status = sandbox.status.get_or_insert_with(|| SandboxStatus { + sandbox_name: sandbox_name.clone(), + ..Default::default() + }); + status.main_process = Some(MainProcessStatus { + state: MainProcessState::Exited as i32, + generation: exit.generation.clone(), + exit_code: exit.exit_code, + signal: exit.signal, + started_at_ms: exit.started_at_ms, + finished_at_ms: exit.finished_at_ms, + }); + upsert_ready_condition( + &mut sandbox.status, + &sandbox_name, + SandboxCondition { + r#type: "Ready".to_string(), + status: "False".to_string(), + reason: "MainProcessExited".to_string(), + message: "Canonical main process exited".to_string(), + last_transition_time: String::new(), + }, + ); + sandbox.set_phase(SandboxPhase::Error as i32); +} + /// Connect to an unmanaged remote compute driver that is already listening on /// `socket_path` and return the acquired endpoint. /// @@ -3210,6 +3338,19 @@ fn driver_sandbox_spec_from_public( } }), sandbox_token: String::new(), + main_process: Some(spec.main_process.as_ref().map_or_else( + || openshell_core::proto::compute::v1::MainProcessSpec { + command: vec!["/bin/bash".to_string(), "-l".to_string()], + terminal: true, + ..Default::default() + }, + |main_process| openshell_core::proto::compute::v1::MainProcessSpec { + command: main_process.command.clone(), + environment: main_process.environment.clone(), + working_directory: main_process.working_directory.clone(), + terminal: main_process.terminal, + }, + )), }) } @@ -3481,6 +3622,7 @@ fn public_status_from_driver( .collect(), phase: phase as i32, current_policy_version, + main_process: None, } } @@ -3488,6 +3630,16 @@ fn apply_driver_snapshot(sandbox: &mut Sandbox, incoming: &DriverSandbox, sessio let old_phase = SandboxPhase::try_from(sandbox.phase()).unwrap_or(SandboxPhase::Unknown); let sandbox_name = &incoming.name; + // Error is terminal until an explicit future lifecycle operation changes + // desired state. In particular, a still-running backend snapshot must not + // revive a sandbox whose canonical process has exited. + if old_phase == SandboxPhase::Error { + if let Some(metadata) = sandbox.metadata.as_mut() { + metadata.name.clone_from(sandbox_name); + } + return; + } + let cpv = sandbox.current_policy_version(); let (mut phase, mut status) = incoming.status.as_ref().map_or_else( || { @@ -3543,6 +3695,23 @@ fn apply_driver_snapshot(sandbox: &mut Sandbox, incoming: &DriverSandbox, sessio { status.sandbox_name.clone_from(sandbox_name); } + if let Some(status) = status.as_mut() { + let mut main_process = sandbox + .status + .as_ref() + .and_then(|current| current.main_process.clone()); + if phase == SandboxPhase::Error + && let Some(terminal) = main_process.as_mut() + && MainProcessState::try_from(terminal.state).unwrap_or(MainProcessState::Unspecified) + == MainProcessState::Running + { + terminal.state = MainProcessState::Exited as i32; + terminal.exit_code = None; + terminal.signal = None; + terminal.finished_at_ms = crate::persistence::current_time_ms(); + } + status.main_process = main_process; + } if old_phase != phase { info!( @@ -3853,6 +4022,7 @@ impl ComputeDriver for NoopTestDriver { driver_name: "noop-test-driver".to_string(), driver_version: "test".to_string(), default_image: "openshell/sandbox:test".to_string(), + supports_main_process: true, }, )) } @@ -3993,11 +4163,13 @@ pub async fn new_test_runtime_with_driver( name: driver_name.to_string(), driver_name: driver_name.to_string(), driver_version: "test".to_string(), + supports_main_process: true, }, shutdown_cleanup: None, startup_starter: None, driver_process: None, default_image: "openshell/sandbox:test".to_string(), + supports_main_process: true, store, sandbox_index: SandboxIndex::new(), sandbox_watch_bus: SandboxWatchBus::new(), @@ -4157,6 +4329,7 @@ mod tests { driver_name: "test-driver".to_string(), driver_version: "test".to_string(), default_image: "openshell/sandbox:test".to_string(), + supports_main_process: true, })) } @@ -4455,6 +4628,7 @@ mod tests { driver_name: "controlled-test-driver".to_string(), driver_version: "test".to_string(), default_image: "openshell/sandbox:test".to_string(), + supports_main_process: true, })) } @@ -4645,11 +4819,13 @@ mod tests { name: "test-driver".to_string(), driver_name: "test-driver".to_string(), driver_version: "test".to_string(), + supports_main_process: true, }, shutdown_cleanup: None, startup_starter, driver_process: None, default_image: "openshell/sandbox:test".to_string(), + supports_main_process: true, store, sandbox_index: SandboxIndex::new(), sandbox_watch_bus: SandboxWatchBus::new(), @@ -4673,6 +4849,25 @@ mod tests { ); } + #[tokio::test] + async fn canonical_process_requires_driver_capability() { + let mut runtime = test_runtime(Arc::new(TestDriver::default())).await; + runtime.supports_main_process = false; + let mut sandbox = sandbox_record("sb-1", "sandbox-a", SandboxPhase::Provisioning); + sandbox.spec = Some(SandboxSpec { + main_process: Some(openshell_core::proto::MainProcessSpec::default()), + ..Default::default() + }); + + let error = runtime.validate_sandbox_create(&sandbox).await.unwrap_err(); + assert_eq!(error.code(), Code::FailedPrecondition); + assert!( + error + .message() + .contains("does not support canonical main processes") + ); + } + fn sandbox_record(id: &str, name: &str, phase: SandboxPhase) -> Sandbox { let mut sandbox = Sandbox { metadata: Some(openshell_core::proto::datamodel::v1::ObjectMeta { @@ -4691,6 +4886,195 @@ mod tests { sandbox } + #[test] + fn main_process_exit_zero_is_terminal_error() { + let mut sandbox = sandbox_record("sb-1", "sandbox-a", SandboxPhase::Ready); + apply_main_process_exit( + &mut sandbox, + &MainProcessExit { + generation: "generation-1".into(), + exit_code: Some(0), + signal: None, + started_at_ms: 10, + finished_at_ms: 20, + }, + ); + + assert_eq!( + SandboxPhase::try_from(sandbox.phase()), + Ok(SandboxPhase::Error) + ); + let status = sandbox.status.as_ref().unwrap(); + let main = status.main_process.as_ref().unwrap(); + assert_eq!(main.exit_code, Some(0)); + assert_eq!(main.state, MainProcessState::Exited as i32); + assert!(status.conditions.iter().any(|condition| { + condition.r#type == "Ready" + && condition.status == "False" + && condition.reason == "MainProcessExited" + })); + } + + #[tokio::test] + async fn stale_main_process_exit_cannot_replace_active_generation() { + let runtime = test_runtime(Arc::new(TestDriver::default())).await; + let sandbox = sandbox_record("sb-1", "sandbox-a", SandboxPhase::Provisioning); + runtime.store.put_message(&sandbox).await.unwrap(); + runtime + .supervisor_session_connected("sb-1", "generation-2") + .await + .unwrap(); + + let error = runtime + .main_process_exited( + "sb-1", + &MainProcessExit { + generation: "generation-1".into(), + exit_code: Some(0), + signal: None, + started_at_ms: 10, + finished_at_ms: 20, + }, + ) + .await + .unwrap_err(); + assert!(error.contains("stale main-process exit generation")); + let stored = runtime + .store + .get_message::("sb-1") + .await + .unwrap() + .unwrap(); + assert_eq!(stored.phase(), SandboxPhase::Ready as i32); + assert_eq!( + stored.status.unwrap().main_process.unwrap().generation, + "generation-2" + ); + } + + #[tokio::test] + async fn duplicate_main_process_exit_is_idempotent() { + let runtime = test_runtime(Arc::new(TestDriver::default())).await; + let sandbox = sandbox_record("sb-1", "sandbox-a", SandboxPhase::Provisioning); + runtime.store.put_message(&sandbox).await.unwrap(); + runtime + .supervisor_session_connected("sb-1", "generation-1") + .await + .unwrap(); + let exit = MainProcessExit { + generation: "generation-1".into(), + exit_code: Some(9), + signal: None, + started_at_ms: 10, + finished_at_ms: 20, + }; + + runtime.main_process_exited("sb-1", &exit).await.unwrap(); + runtime.main_process_exited("sb-1", &exit).await.unwrap(); + let stored = runtime + .store + .get_message::("sb-1") + .await + .unwrap() + .unwrap(); + assert_eq!(stored.phase(), SandboxPhase::Error as i32); + assert_eq!( + stored.status.unwrap().main_process.unwrap().exit_code, + Some(9) + ); + } + + #[tokio::test] + async fn precise_exit_enriches_driver_terminal_fallback() { + let runtime = test_runtime(Arc::new(TestDriver::default())).await; + let mut sandbox = sandbox_record("sb-1", "sandbox-a", SandboxPhase::Error); + sandbox.status = Some(SandboxStatus { + phase: SandboxPhase::Error as i32, + main_process: Some(MainProcessStatus { + state: MainProcessState::Exited as i32, + generation: "generation-1".into(), + started_at_ms: 10, + finished_at_ms: 15, + ..Default::default() + }), + ..Default::default() + }); + runtime.store.put_message(&sandbox).await.unwrap(); + + runtime + .main_process_exited( + "sb-1", + &MainProcessExit { + generation: "generation-1".into(), + exit_code: Some(7), + signal: None, + started_at_ms: 10, + finished_at_ms: 20, + }, + ) + .await + .unwrap(); + + let stored = runtime + .store + .get_message::("sb-1") + .await + .unwrap() + .unwrap(); + assert_eq!(stored.phase(), SandboxPhase::Error as i32); + let main = stored.status.unwrap().main_process.unwrap(); + assert_eq!(main.exit_code, Some(7)); + assert_eq!(main.finished_at_ms, 20); + } + + #[tokio::test] + async fn intentional_stop_ignores_main_process_exit_report() { + let runtime = test_runtime(Arc::new(TestDriver::default())).await; + for (id, phase) in [ + ("sb-stopping", SandboxPhase::Stopping), + ("sb-stopped", SandboxPhase::Stopped), + ] { + let mut sandbox = sandbox_record(id, id, phase); + sandbox.status = Some(SandboxStatus { + phase: phase as i32, + main_process: Some(MainProcessStatus { + state: MainProcessState::Running as i32, + generation: "generation-1".into(), + started_at_ms: 10, + ..Default::default() + }), + ..Default::default() + }); + runtime.store.put_message(&sandbox).await.unwrap(); + + runtime + .main_process_exited( + id, + &MainProcessExit { + generation: "generation-1".into(), + exit_code: None, + signal: Some(15), + started_at_ms: 10, + finished_at_ms: 20, + }, + ) + .await + .unwrap(); + + let stored = runtime + .store + .get_message::(id) + .await + .unwrap() + .unwrap(); + assert_eq!(stored.phase(), phase as i32); + assert_eq!( + stored.status.unwrap().main_process.unwrap().state, + MainProcessState::Running as i32 + ); + } + } + fn ssh_session_record(id: &str, sandbox_id: &str) -> SshSession { SshSession { metadata: Some(openshell_core::proto::datamodel::v1::ObjectMeta { @@ -7169,7 +7553,17 @@ mod tests { #[tokio::test] async fn non_deleting_container_exit_still_transitions_to_error() { let runtime = test_runtime(Arc::new(TestDriver::default())).await; - let sandbox = sandbox_record("sb-1", "sandbox-a", SandboxPhase::Ready); + let mut sandbox = sandbox_record("sb-1", "sandbox-a", SandboxPhase::Ready); + sandbox.status = Some(SandboxStatus { + sandbox_name: "sandbox-a".to_string(), + main_process: Some(MainProcessStatus { + state: MainProcessState::Running as i32, + generation: "generation-1".to_string(), + started_at_ms: 10, + ..Default::default() + }), + ..Default::default() + }); runtime.store.put_message(&sandbox).await.unwrap(); let mut exited = ready_driver_sandbox("sb-1", "sandbox-a"); exited.status = Some(make_driver_status(make_driver_condition( @@ -7189,6 +7583,12 @@ mod tests { SandboxPhase::try_from(stored.phase()).unwrap(), SandboxPhase::Error ); + let main = stored.status.unwrap().main_process.unwrap(); + assert_eq!(main.state, MainProcessState::Exited as i32); + assert_eq!(main.generation, "generation-1"); + assert_eq!(main.started_at_ms, 10); + assert_eq!(main.exit_code, None); + assert_eq!(main.signal, None); } #[tokio::test] @@ -7302,7 +7702,10 @@ mod tests { let sandbox = sandbox_record("sb-1", "sandbox-a", SandboxPhase::Provisioning); runtime.store.put_message(&sandbox).await.unwrap(); - runtime.supervisor_session_connected("sb-1").await.unwrap(); + runtime + .supervisor_session_connected("sb-1", "test-generation") + .await + .unwrap(); let stored = runtime .store @@ -7545,6 +7948,10 @@ mod tests { SandboxPhase::try_from(stored.phase()).unwrap(), SandboxPhase::Error ); + assert!( + stored.status.unwrap().main_process.is_none(), + "a provisioning failure must not fabricate a main-process exit" + ); } #[tokio::test] @@ -7557,7 +7964,10 @@ mod tests { // Promote to Ready via supervisor session connect. register_test_supervisor_session(&runtime, "sb-1"); - runtime.supervisor_session_connected("sb-1").await.unwrap(); + runtime + .supervisor_session_connected("sb-1", "test-generation") + .await + .unwrap(); let stored = runtime .store .get_message::("sb-1") diff --git a/crates/openshell-server/src/grpc/mod.rs b/crates/openshell-server/src/grpc/mod.rs index 2c52acbe12..ba9e4f6d60 100644 --- a/crates/openshell-server/src/grpc/mod.rs +++ b/crates/openshell-server/src/grpc/mod.rs @@ -253,6 +253,7 @@ impl OpenShell for OpenShellService { capabilities: Some(ComputeDriverCapabilities { driver_name: driver.driver_name.clone(), driver_version: driver.driver_version.clone(), + supports_main_process: driver.supports_main_process, }), }) .collect(); diff --git a/crates/openshell-server/src/grpc/sandbox.rs b/crates/openshell-server/src/grpc/sandbox.rs index d5dd4e04e4..f56ae99850 100644 --- a/crates/openshell-server/src/grpc/sandbox.rs +++ b/crates/openshell-server/src/grpc/sandbox.rs @@ -22,10 +22,10 @@ use openshell_core::proto::{ DetachSandboxProviderRequest, DetachSandboxProviderResponse, ExecSandboxEvent, ExecSandboxExit, ExecSandboxInput, ExecSandboxRequest, ExecSandboxStderr, ExecSandboxStdout, GetSandboxRequest, ListSandboxProvidersRequest, ListSandboxProvidersResponse, ListSandboxesRequest, - ListSandboxesResponse, Provider, RevokeSshSessionRequest, RevokeSshSessionResponse, - SandboxResponse, SandboxStreamEvent, SshRelayTarget, StartSandboxRequest, StopSandboxRequest, - TcpForwardFrame, TcpForwardInit, TcpRelayTarget, WatchSandboxRequest, relay_open, - tcp_forward_init, + ListSandboxesResponse, MainProcessSpec, Provider, RevokeSshSessionRequest, + RevokeSshSessionResponse, SandboxResponse, SandboxStreamEvent, SshRelayTarget, + StartSandboxRequest, StopSandboxRequest, TcpForwardFrame, TcpForwardInit, TcpRelayTarget, + WatchSandboxRequest, relay_open, tcp_forward_init, }; use openshell_core::proto::{Sandbox, SandboxPhase, SandboxTemplate, SshSession}; use openshell_core::telemetry::{ @@ -217,10 +217,19 @@ async fn handle_create_sandbox_inner( ) -> Result, Status> { let principal = super::extract_principal(&request)?; let request = request.into_inner(); - let spec = request + let mut spec = request .spec .ok_or_else(|| Status::invalid_argument("spec is required"))?; + // Every newly persisted sandbox has one explicit canonical process. This + // portable default also preserves compatibility with callers compiled + // before the main-process field was introduced. + spec.main_process.get_or_insert_with(|| MainProcessSpec { + command: vec!["/bin/bash".to_string(), "-l".to_string()], + terminal: true, + ..MainProcessSpec::default() + }); + // Validate field sizes before any I/O (fail fast on oversized payloads). validate_sandbox_spec(&request.name, &spec)?; @@ -262,7 +271,6 @@ async fn handle_create_sandbox_inner( .await?; // Ensure the template always carries the resolved image. - let mut spec = spec; let template = spec.template.get_or_insert_with(SandboxTemplate::default); if template.image.is_empty() { template.image = state.compute.default_image().to_string(); diff --git a/crates/openshell-server/src/grpc/validation.rs b/crates/openshell-server/src/grpc/validation.rs index f71623fa3d..0beb33b0da 100644 --- a/crates/openshell-server/src/grpc/validation.rs +++ b/crates/openshell-server/src/grpc/validation.rs @@ -10,8 +10,8 @@ use openshell_core::ComputeDriverKind; use openshell_core::proto::{ - CredentialHandle, ExecSandboxRequest, Provider, SandboxPolicy as ProtoSandboxPolicy, - SandboxTemplate, + CredentialHandle, ExecSandboxRequest, MainProcessSpec, Provider, + SandboxPolicy as ProtoSandboxPolicy, SandboxTemplate, }; use prost::Message; use tonic::Status; @@ -51,6 +51,10 @@ pub(super) const MAX_EXEC_COMMAND_ARGS: usize = 1024; pub(super) const MAX_EXEC_ARG_LEN: usize = 32 * 1024; // 32 KiB /// Maximum length of the workdir field (bytes). pub(super) const MAX_EXEC_WORKDIR_LEN: usize = 4096; +/// Maximum number of entries in the canonical main-process argv. +pub(super) const MAX_MAIN_PROCESS_ARGS: usize = 256; +/// Maximum aggregate byte size of the canonical main-process argv. +pub(super) const MAX_MAIN_PROCESS_ARGV_SIZE: usize = 256 * 1024; /// Validate exec request size limits and field-specific character constraints. /// @@ -212,6 +216,11 @@ pub(super) fn validate_sandbox_spec( // --- spec.resource_requirements.gpu --- validate_gpu_request_fields(spec)?; + // --- spec.main_process --- + if let Some(main_process) = spec.main_process.as_ref() { + validate_main_process_spec(main_process)?; + } + // --- spec.policy serialized size --- if let Some(ref policy) = spec.policy { let size = policy.encoded_len(); @@ -225,6 +234,67 @@ pub(super) fn validate_sandbox_spec( Ok(()) } +fn validate_main_process_spec(main_process: &MainProcessSpec) -> Result<(), Status> { + if main_process.command.is_empty() { + return Err(Status::invalid_argument( + "spec.main_process.command must not be empty", + )); + } + if main_process.command.len() > MAX_MAIN_PROCESS_ARGS { + return Err(Status::invalid_argument(format!( + "spec.main_process.command exceeds {MAX_MAIN_PROCESS_ARGS} argument limit" + ))); + } + if main_process.command[0].is_empty() { + return Err(Status::invalid_argument( + "spec.main_process.command[0] must not be empty", + )); + } + let argv_size: usize = main_process.command.iter().map(String::len).sum(); + if argv_size > MAX_MAIN_PROCESS_ARGV_SIZE { + return Err(Status::invalid_argument(format!( + "spec.main_process.command total size exceeds {MAX_MAIN_PROCESS_ARGV_SIZE} byte limit" + ))); + } + for (index, argument) in main_process.command.iter().enumerate() { + if argument.len() > MAX_EXEC_ARG_LEN { + return Err(Status::invalid_argument(format!( + "spec.main_process.command[{index}] exceeds {MAX_EXEC_ARG_LEN} byte limit" + ))); + } + reject_null_char(argument, &format!("spec.main_process.command[{index}]"))?; + } + + validate_string_map( + &main_process.environment, + MAX_ENVIRONMENT_ENTRIES, + MAX_MAP_KEY_LEN, + MAX_MAP_VALUE_LEN, + "spec.main_process.environment", + )?; + validate_env_entries(&main_process.environment, "spec.main_process.environment")?; + + let workdir = &main_process.working_directory; + if !workdir.is_empty() { + if workdir.len() > MAX_EXEC_WORKDIR_LEN { + return Err(Status::invalid_argument(format!( + "spec.main_process.working_directory exceeds {MAX_EXEC_WORKDIR_LEN} byte limit" + ))); + } + reject_control_chars(workdir, "spec.main_process.working_directory")?; + if !workdir.starts_with('/') + || workdir + .split('/') + .any(|component| component == "." || component == "..") + { + return Err(Status::invalid_argument( + "spec.main_process.working_directory must be an absolute normalized path", + )); + } + } + Ok(()) +} + fn validate_gpu_request_fields(spec: &openshell_core::proto::SandboxSpec) -> Result<(), Status> { if openshell_core::gpu::sandbox_gpu_count(spec.resource_requirements.as_ref()) == Some(0) { return Err(Status::invalid_argument("gpu count must be greater than 0")); @@ -1020,6 +1090,46 @@ mod tests { assert!(validate_sandbox_spec("", &default_spec()).is_ok()); } + #[test] + fn validate_sandbox_spec_accepts_exact_main_process_argv() { + let spec = SandboxSpec { + main_process: Some(MainProcessSpec { + command: vec!["/bin/sh".into(), "-c".into(), "printf 'a b'".into()], + working_directory: "/sandbox/work".into(), + terminal: false, + ..Default::default() + }), + ..Default::default() + }; + validate_sandbox_spec("", &spec).unwrap(); + } + + #[test] + fn validate_sandbox_spec_rejects_empty_main_process_command() { + let spec = SandboxSpec { + main_process: Some(MainProcessSpec::default()), + ..Default::default() + }; + let error = validate_sandbox_spec("", &spec).unwrap_err(); + assert_eq!(error.code(), Code::InvalidArgument); + assert!(error.message().contains("main_process.command")); + } + + #[test] + fn validate_sandbox_spec_rejects_non_normal_main_process_workdir() { + let spec = SandboxSpec { + main_process: Some(MainProcessSpec { + command: vec!["/bin/true".into()], + working_directory: "/sandbox/../root".into(), + ..Default::default() + }), + ..Default::default() + }; + let error = validate_sandbox_spec("", &spec).unwrap_err(); + assert_eq!(error.code(), Code::InvalidArgument); + assert!(error.message().contains("absolute normalized path")); + } + #[test] fn validate_sandbox_spec_accepts_at_limit_name() { let name = "a".repeat(MAX_ROUTABLE_NAME_LEN); diff --git a/crates/openshell-server/src/supervisor_session.rs b/crates/openshell-server/src/supervisor_session.rs index 11ef55978b..39a227ef82 100644 --- a/crates/openshell-server/src/supervisor_session.rs +++ b/crates/openshell-server/src/supervisor_session.rs @@ -13,8 +13,9 @@ use tracing::{debug, info, warn}; use uuid::Uuid; use openshell_core::proto::{ - GatewayMessage, RelayFrame, RelayInit, RelayOpen, Sandbox, SandboxPhase, SessionAccepted, - SshRelayTarget, SupervisorMessage, gateway_message, relay_open, supervisor_message, + GatewayMessage, MainProcessExitAck, RelayFrame, RelayInit, RelayOpen, Sandbox, SandboxPhase, + SessionAccepted, SshRelayTarget, SupervisorMessage, gateway_message, relay_open, + supervisor_message, }; use openshell_core::transport_errors::is_expected_transport_close_status; @@ -713,15 +714,23 @@ pub async fn handle_connect_supervisor( "supervisor session: accepted" ); - // Step 2: Create the outbound channel and register the session. + // Step 2: Create the outbound channel. Exit-report-only sessions are + // deliberately not registered: they must not supersede the live relay + // session or mutate sandbox readiness. let (tx, rx) = mpsc::channel::(64); let (shutdown_tx, shutdown_rx) = oneshot::channel::<()>(); - let superseded = state.supervisor_sessions.register( - sandbox_id.clone(), - session_id.clone(), - tx.clone(), - shutdown_tx, - ); + let mut exit_report_guard = None; + let superseded = if hello.exit_report_only { + exit_report_guard = Some(shutdown_tx); + false + } else { + state.supervisor_sessions.register( + sandbox_id.clone(), + session_id.clone(), + tx.clone(), + shutdown_tx, + ) + }; if superseded { info!( sandbox_id = %sandbox_id, @@ -753,25 +762,28 @@ pub async fn handle_connect_supervisor( .await; } - if let Err(err) = state - .compute - .supervisor_session_connected(&sandbox_id) - .await - { - warn!( - sandbox_id = %sandbox_id, - session_id = %session_id, - error = %err, - "supervisor session: failed to mark sandbox ready" - ); - } else { - state.telemetry.sandbox_session_connected(&sandbox_id); + if !hello.exit_report_only { + if let Err(err) = state + .compute + .supervisor_session_connected(&sandbox_id, &hello.instance_id) + .await + { + warn!( + sandbox_id = %sandbox_id, + session_id = %session_id, + error = %err, + "supervisor session: failed to mark sandbox ready" + ); + } else { + state.telemetry.sandbox_session_connected(&sandbox_id); + } } // Step 4: Spawn the session loop that reads inbound messages. let state_clone = Arc::clone(state); let sandbox_id_clone = sandbox_id.clone(); tokio::spawn(async move { + let _exit_report_guard = exit_report_guard; run_session_loop( &state_clone, &sandbox_id_clone, @@ -781,9 +793,10 @@ pub async fn handle_connect_supervisor( shutdown_rx, ) .await; - let still_ours = state_clone - .supervisor_sessions - .remove_if_current(&sandbox_id_clone, &session_id); + let still_ours = !hello.exit_report_only + && state_clone + .supervisor_sessions + .remove_if_current(&sandbox_id_clone, &session_id); if still_ours { info!(sandbox_id = %sandbox_id_clone, session_id = %session_id, "supervisor session: ended"); state_clone @@ -837,7 +850,7 @@ async fn run_session_loop( msg = inbound.message() => { match msg { Ok(Some(msg)) => { - handle_supervisor_message(state, sandbox_id, session_id, msg); + handle_supervisor_message(state, sandbox_id, session_id, tx, msg).await; } Ok(None) => { info!(sandbox_id = %sandbox_id, session_id = %session_id, "supervisor session: stream closed by supervisor"); @@ -880,10 +893,11 @@ async fn run_session_loop( } } -fn handle_supervisor_message( +async fn handle_supervisor_message( state: &Arc, sandbox_id: &str, session_id: &str, + tx: &mpsc::Sender, msg: SupervisorMessage, ) { match msg.payload { @@ -921,6 +935,29 @@ fn handle_supervisor_message( "supervisor session: relay closed by supervisor" ); } + Some(supervisor_message::Payload::MainProcessExit(exit)) => { + match state.compute.main_process_exited(sandbox_id, &exit).await { + Ok(()) => { + let _ = tx + .send(GatewayMessage { + payload: Some(gateway_message::Payload::MainProcessExitAck( + MainProcessExitAck { + generation: exit.generation, + }, + )), + }) + .await; + } + Err(error) => { + warn!( + sandbox_id, + session_id, + %error, + "supervisor session: failed to persist main-process exit" + ); + } + } + } _ => { warn!( sandbox_id = %sandbox_id, diff --git a/crates/openshell-server/src/test_support.rs b/crates/openshell-server/src/test_support.rs index f8124ded6c..b392dd0e23 100644 --- a/crates/openshell-server/src/test_support.rs +++ b/crates/openshell-server/src/test_support.rs @@ -241,6 +241,7 @@ impl ComputeDriver for FakeComputeDriver { driver_name: state.driver_name.clone(), driver_version: state.driver_version.clone(), default_image: state.default_image.clone(), + supports_main_process: true, } }); Ok(Response::new(response)) diff --git a/crates/openshell-supervisor-process/src/lib.rs b/crates/openshell-supervisor-process/src/lib.rs index ca93230929..743942faa4 100644 --- a/crates/openshell-supervisor-process/src/lib.rs +++ b/crates/openshell-supervisor-process/src/lib.rs @@ -13,6 +13,7 @@ pub mod debug_rpc; #[cfg(unix)] pub mod identity; pub mod log_push; +pub mod main_session; pub mod managed_children; pub mod process; pub mod run; diff --git a/crates/openshell-supervisor-process/src/main_session.rs b/crates/openshell-supervisor-process/src/main_session.rs new file mode 100644 index 0000000000..0e8d42f517 --- /dev/null +++ b/crates/openshell-supervisor-process/src/main_session.rs @@ -0,0 +1,320 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +//! Retained I/O multiplexer for the canonical sandbox process. + +use std::collections::VecDeque; +use std::io::{Read, Write}; +use std::os::fd::AsRawFd; +use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering}; +use std::sync::{Arc, Mutex}; + +use nix::pty::Winsize; +use tokio::io::AsyncReadExt; +use tokio::sync::Notify; +use tokio::sync::broadcast; + +use crate::process::ProcessIo; + +const OUTPUT_BUFFER_BYTES: usize = 1024 * 1024; +const OUTPUT_CHANNEL_CHUNKS: usize = 512; + +#[derive(Clone, Debug)] +pub enum MainOutput { + Stdout(Vec), + Stderr(Vec), + Exit(i32), +} + +impl MainOutput { + fn len(&self) -> usize { + match self { + Self::Stdout(data) | Self::Stderr(data) => data.len(), + Self::Exit(_) => 0, + } + } +} + +pub struct MainSession { + pid: u32, + terminal: bool, + input: tokio::sync::mpsc::Sender>, + output: broadcast::Sender, + replay: Mutex<(VecDeque, usize)>, + input_owner: Mutex>, + next_owner: AtomicU64, + pty_master: Option>, + readers_remaining: AtomicUsize, + readers_done: Notify, + exit_code: Mutex>, +} + +impl MainSession { + #[cfg(test)] + pub fn inert() -> Arc { + let (input, _input_rx) = tokio::sync::mpsc::channel(64); + let (output, _) = broadcast::channel(OUTPUT_CHANNEL_CHUNKS); + Arc::new(Self { + pid: 1, + terminal: false, + input, + output, + replay: Mutex::new((VecDeque::new(), 0)), + input_owner: Mutex::new(None), + next_owner: AtomicU64::new(1), + pty_master: None, + readers_remaining: AtomicUsize::new(0), + readers_done: Notify::new(), + exit_code: Mutex::new(None), + }) + } + + #[cfg(test)] + pub fn terminal_for_test() -> (Arc, std::fs::File) { + let pty = nix::pty::openpty(None, None).expect("open test PTY"); + let slave = std::fs::File::from(pty.slave); + ( + Self::new(ProcessIo::Pty(std::fs::File::from(pty.master)), 1), + slave, + ) + } + + #[cfg(test)] + #[allow(unsafe_code)] + pub fn terminal_size_for_test(&self) -> (u16, u16) { + let master = self.pty_master.as_ref().expect("terminal PTY master"); + let mut winsize: libc::winsize = unsafe { std::mem::zeroed() }; + let result = unsafe { libc::ioctl(master.as_raw_fd(), libc::TIOCGWINSZ, &mut winsize) }; + assert_eq!(result, 0, "read terminal dimensions"); + (winsize.ws_col, winsize.ws_row) + } + + #[must_use] + pub fn new(io: ProcessIo, pid: u32) -> Arc { + let terminal = matches!(io, ProcessIo::Pty(_)); + let (input, input_rx) = tokio::sync::mpsc::channel::>(64); + let (output, _) = broadcast::channel(OUTPUT_CHANNEL_CHUNKS); + let pty_master = match &io { + ProcessIo::Pty(master) => master.try_clone().ok().map(Arc::new), + ProcessIo::Pipes { .. } => None, + }; + let session = Arc::new(Self { + pid, + terminal, + input, + output, + replay: Mutex::new((VecDeque::new(), 0)), + input_owner: Mutex::new(None), + next_owner: AtomicU64::new(1), + pty_master, + readers_remaining: AtomicUsize::new(if terminal { 1 } else { 2 }), + readers_done: Notify::new(), + exit_code: Mutex::new(None), + }); + Self::start_io(&session, io, input_rx); + session + } + + fn start_io( + this: &Arc, + io: ProcessIo, + mut input_rx: tokio::sync::mpsc::Receiver>, + ) { + match io { + ProcessIo::Pty(master) => { + let mut reader = master.try_clone().expect("PTY master clone"); + let mut writer = master; + let output = Arc::clone(this); + std::thread::spawn(move || { + let mut buffer = [0u8; 4096]; + loop { + match reader.read(&mut buffer) { + Ok(0) | Err(_) => break, + Ok(read) => output.publish(MainOutput::Stdout(buffer[..read].to_vec())), + } + } + output.reader_finished(); + }); + std::thread::spawn(move || { + while let Some(data) = input_rx.blocking_recv() { + if writer.write_all(&data).is_err() { + break; + } + let _ = writer.flush(); + } + }); + } + ProcessIo::Pipes { + mut stdin, + mut stdout, + mut stderr, + } => { + let stdout_session = Arc::clone(this); + tokio::spawn(async move { + let mut buffer = [0u8; 4096]; + loop { + match stdout.read(&mut buffer).await { + Ok(0) | Err(_) => break, + Ok(read) => { + stdout_session.publish(MainOutput::Stdout(buffer[..read].to_vec())); + } + } + } + stdout_session.reader_finished(); + }); + let stderr_session = Arc::clone(this); + tokio::spawn(async move { + let mut buffer = [0u8; 4096]; + loop { + match stderr.read(&mut buffer).await { + Ok(0) | Err(_) => break, + Ok(read) => { + stderr_session.publish(MainOutput::Stderr(buffer[..read].to_vec())); + } + } + } + stderr_session.reader_finished(); + }); + let runtime = tokio::runtime::Handle::current(); + std::thread::spawn(move || { + while let Some(data) = input_rx.blocking_recv() { + if runtime + .block_on(tokio::io::AsyncWriteExt::write_all(&mut stdin, &data)) + .is_err() + { + break; + } + let _ = runtime.block_on(tokio::io::AsyncWriteExt::flush(&mut stdin)); + } + }); + } + } + } + + fn publish(&self, event: MainOutput) { + // Keep replay insertion and live publication under one lock. A new + // subscriber takes this same lock before subscribing, so an event is + // observed either in the replay snapshot or on the live channel, + // never both. + { + let mut replay = self.replay.lock().expect("main replay lock poisoned"); + replay.1 += event.len(); + replay.0.push_back(event.clone()); + while replay.1 > OUTPUT_BUFFER_BYTES { + let Some(removed) = replay.0.pop_front() else { + break; + }; + replay.1 = replay.1.saturating_sub(removed.len()); + } + let _ = self.output.send(event); + } + } + + fn reader_finished(&self) { + if self.readers_remaining.fetch_sub(1, Ordering::AcqRel) == 1 { + self.readers_done.notify_waiters(); + } + } + + pub async fn finish(&self, exit_code: i32) { + let notified = self.readers_done.notified(); + if self.readers_remaining.load(Ordering::Acquire) != 0 { + let _ = tokio::time::timeout(std::time::Duration::from_secs(2), notified).await; + } + *self.exit_code.lock().expect("main exit lock poisoned") = Some(exit_code); + self.publish(MainOutput::Exit(exit_code)); + } + + pub fn subscribe(&self) -> (Vec, broadcast::Receiver) { + let replay = self.replay.lock().expect("main replay lock poisoned"); + let receiver = self.output.subscribe(); + let replay = replay.0.iter().cloned().collect(); + (replay, receiver) + } + + pub fn acquire_input(&self) -> Result<(u64, tokio::sync::mpsc::Sender>), &'static str> { + let mut owner = self.input_owner.lock().expect("main input lock poisoned"); + if owner.is_some() { + return Err("canonical main process already has an input owner"); + } + let id = self.next_owner.fetch_add(1, Ordering::Relaxed); + *owner = Some(id); + Ok((id, self.input.clone())) + } + + pub fn release_input(&self, id: u64) { + let mut owner = self.input_owner.lock().expect("main input lock poisoned"); + if *owner == Some(id) { + *owner = None; + } + } + + pub fn resize(&self, columns: u32, rows: u32, pixel_width: u32, pixel_height: u32) { + let Some(master) = self.pty_master.as_ref() else { + return; + }; + let winsize = Winsize { + ws_row: u16::try_from(rows.max(1)).unwrap_or(u16::MAX), + ws_col: u16::try_from(columns.max(1)).unwrap_or(u16::MAX), + ws_xpixel: u16::try_from(pixel_width).unwrap_or(u16::MAX), + ws_ypixel: u16::try_from(pixel_height).unwrap_or(u16::MAX), + }; + #[allow(unsafe_code)] + unsafe { + libc::ioctl(master.as_raw_fd(), libc::TIOCSWINSZ, &winsize); + } + } + + pub fn signal_group(&self, signal: nix::sys::signal::Signal) -> Result<(), nix::errno::Errno> { + let pid = i32::try_from(self.pid).unwrap_or(i32::MAX); + nix::sys::signal::kill(nix::unistd::Pid::from_raw(-pid), signal) + } + + #[must_use] + pub const fn terminal(&self) -> bool { + self.terminal + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn input_lease_has_one_owner_and_can_be_reacquired() { + let session = MainSession::inert(); + let (first, _) = session.acquire_input().expect("first owner"); + assert!(session.acquire_input().is_err()); + + session.release_input(first); + let (second, _) = session.acquire_input().expect("replacement owner"); + assert_ne!(first, second); + } + + #[tokio::test] + async fn subscribers_receive_replay_then_live_output() { + let session = MainSession::inert(); + session.publish(MainOutput::Stdout(b"before".to_vec())); + + let (replay, mut live) = session.subscribe(); + assert!(matches!( + replay.as_slice(), + [MainOutput::Stdout(data)] if data == b"before" + )); + + session.publish(MainOutput::Stderr(b"after".to_vec())); + assert!(matches!( + live.recv().await.expect("live output"), + MainOutput::Stderr(data) if data == b"after" + )); + } + + #[tokio::test] + async fn exit_is_replayed_once_to_late_subscribers() { + let session = MainSession::inert(); + session.finish(0).await; + + let (replay, _live) = session.subscribe(); + assert!(matches!(replay.as_slice(), [MainOutput::Exit(0)])); + } +} diff --git a/crates/openshell-supervisor-process/src/process.rs b/crates/openshell-supervisor-process/src/process.rs index 659fe3dc06..6b3fcdfd00 100644 --- a/crates/openshell-supervisor-process/src/process.rs +++ b/crates/openshell-supervisor-process/src/process.rs @@ -15,8 +15,10 @@ use nix::unistd::{Gid, Group, Pid, Uid, User}; use openshell_core::policy::{NetworkMode, SandboxPolicy}; use std::collections::HashMap; use std::ffi::CString; +#[cfg(unix)] +use std::os::fd::AsRawFd; #[cfg(target_os = "linux")] -use std::os::fd::{AsRawFd, OwnedFd, RawFd}; +use std::os::fd::{OwnedFd, RawFd}; #[cfg(target_os = "linux")] use std::os::unix::ffi::OsStrExt; #[cfg(unix)] @@ -27,7 +29,7 @@ use std::path::PathBuf; use std::process::Stdio; #[cfg(target_os = "linux")] use std::sync::OnceLock; -use tokio::process::{Child, Command}; +use tokio::process::{Child, ChildStderr, ChildStdin, ChildStdout, Command}; use tracing::{debug, info}; /// Process/filesystem enforcement performed by the process supervisor. @@ -545,6 +547,18 @@ fn mount_empty_tmpfs(target: &CString) -> std::io::Result<()> { pub struct ProcessHandle { child: Child, pid: u32, + io: Option, +} + +/// Supervisor-owned canonical-process I/O. These handles outlive individual +/// SSH attachments and are consumed by the main-session multiplexer. +pub enum ProcessIo { + Pty(std::fs::File), + Pipes { + stdin: ChildStdin, + stdout: ChildStdout, + stderr: ChildStderr, + }, } impl ProcessHandle { @@ -559,6 +573,7 @@ impl ProcessHandle { program: &str, args: &[String], workspace: &ResolvedWorkspace, + main_workdir: Option<&str>, interactive: bool, policy: &SandboxPolicy, resolved_identity: ResolvedProcessIdentity, @@ -571,6 +586,7 @@ impl ProcessHandle { program, args, workspace, + main_workdir, interactive, policy, resolved_identity, @@ -592,6 +608,7 @@ impl ProcessHandle { program: &str, args: &[String], workspace: &ResolvedWorkspace, + main_workdir: Option<&str>, interactive: bool, policy: &SandboxPolicy, resolved_identity: ResolvedProcessIdentity, @@ -603,6 +620,7 @@ impl ProcessHandle { program, args, workspace, + main_workdir, interactive, policy, resolved_identity, @@ -618,6 +636,7 @@ impl ProcessHandle { program: &str, args: &[String], workspace: &ResolvedWorkspace, + main_workdir: Option<&str>, interactive: bool, policy: &SandboxPolicy, resolved_identity: ResolvedProcessIdentity, @@ -628,12 +647,32 @@ impl ProcessHandle { ) -> Result { let mut cmd = Command::new(program); cmd.args(args) - .stdin(Stdio::inherit()) - .stdout(Stdio::inherit()) - .stderr(Stdio::inherit()) .kill_on_drop(true) .env(openshell_core::sandbox_env::SANDBOX, "1"); + let mut pty_master = None; + let mut terminal_slave_fd = None; + if interactive { + let winsize = nix::pty::Winsize { + ws_row: 24, + ws_col: 80, + ws_xpixel: 0, + ws_ypixel: 0, + }; + let pty = nix::pty::openpty(Some(&winsize), None).into_diagnostic()?; + let master = std::fs::File::from(pty.master); + let slave = std::fs::File::from(pty.slave); + terminal_slave_fd = Some(slave.as_raw_fd()); + cmd.stdin(slave.try_clone().into_diagnostic()?) + .stdout(slave.try_clone().into_diagnostic()?) + .stderr(slave); + pty_master = Some(master); + } else { + cmd.stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + } + // Strip supervisor-only identity material from the entrypoint's // inherited environment. The entrypoint drops to the sandbox user // before `exec`; without this strip, sandbox code could recover @@ -642,7 +681,7 @@ impl ProcessHandle { inject_provider_env(&mut cmd, provider_env); - if let Some(dir) = workspace.root() { + if let Some(dir) = main_workdir.or_else(|| workspace.root()) { cmd.current_dir(dir); } if let Some(home) = workspace.home() { @@ -719,9 +758,18 @@ impl ProcessHandle { #[allow(unsafe_code)] unsafe { cmd.pre_exec(move || { - if !interactive { - // Create new process group - libc::setpgid(0, 0); + if let Some(slave_fd) = terminal_slave_fd { + if libc::setsid() < 0 { + return Err(std::io::Error::last_os_error()); + } + if libc::ioctl(slave_fd, libc::TIOCSCTTY, 0) < 0 { + return Err(std::io::Error::last_os_error()); + } + } else { + // Create a distinct process group for signal forwarding. + if libc::setpgid(0, 0) < 0 { + return Err(std::io::Error::last_os_error()); + } } // Enter network namespace before applying other restrictions @@ -761,13 +809,27 @@ impl ProcessHandle { } } - let child = cmd.spawn().into_diagnostic()?; + let mut child = cmd.spawn().into_diagnostic()?; let pid = child.id().unwrap_or(0); managed_children::register(pid); + let io = if let Some(master) = pty_master { + ProcessIo::Pty(master) + } else { + ProcessIo::Pipes { + stdin: child.stdin.take().expect("canonical stdin must be piped"), + stdout: child.stdout.take().expect("canonical stdout must be piped"), + stderr: child.stderr.take().expect("canonical stderr must be piped"), + } + }; + debug!(pid, program, "Process spawned"); - Ok(Self { child, pid }) + Ok(Self { + child, + pid, + io: Some(io), + }) } #[cfg(not(target_os = "linux"))] @@ -776,6 +838,7 @@ impl ProcessHandle { program: &str, args: &[String], workspace: &ResolvedWorkspace, + main_workdir: Option<&str>, interactive: bool, policy: &SandboxPolicy, resolved_identity: ResolvedProcessIdentity, @@ -785,19 +848,41 @@ impl ProcessHandle { ) -> Result { let mut cmd = Command::new(program); cmd.args(args) - .stdin(Stdio::inherit()) - .stdout(Stdio::inherit()) - .stderr(Stdio::inherit()) .kill_on_drop(true) .env(openshell_core::sandbox_env::SANDBOX, "1"); + let mut pty_master = None; + let mut terminal_slave_fd = None; + #[cfg(unix)] + if interactive { + let winsize = nix::pty::Winsize { + ws_row: 24, + ws_col: 80, + ws_xpixel: 0, + ws_ypixel: 0, + }; + let pty = nix::pty::openpty(Some(&winsize), None).into_diagnostic()?; + let master = std::fs::File::from(pty.master); + let slave = std::fs::File::from(pty.slave); + terminal_slave_fd = Some(slave.as_raw_fd()); + cmd.stdin(slave.try_clone().into_diagnostic()?) + .stdout(slave.try_clone().into_diagnostic()?) + .stderr(slave); + pty_master = Some(master); + } + if !interactive { + cmd.stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + } + // Strip supervisor-only identity material from the entrypoint's // inherited environment. strip_supervisor_only_env(&mut cmd); inject_provider_env(&mut cmd, provider_env); - if let Some(dir) = workspace.root() { + if let Some(dir) = main_workdir.or_else(|| workspace.root()) { cmd.current_dir(dir); } if let Some(home) = workspace.home() { @@ -825,9 +910,9 @@ impl ProcessHandle { } } - // Set up process group for signal handling (non-interactive mode only). - // In interactive mode, we inherit the parent's process group to maintain - // proper terminal control for shells and interactive programs. + // Create a dedicated session for PTY children and a dedicated process + // group for pipe children so attachment signals target only the + // canonical workload tree. // SAFETY: pre_exec runs after fork but before exec in the child process. // setpgid is async-signal-safe and safe to call in this context. #[cfg(unix)] @@ -837,9 +922,17 @@ impl ProcessHandle { #[allow(unsafe_code)] unsafe { cmd.pre_exec(move || { - if !interactive { - // Create new process group - libc::setpgid(0, 0); + if let Some(slave_fd) = terminal_slave_fd { + if libc::setsid() < 0 { + return Err(std::io::Error::last_os_error()); + } + if libc::ioctl(slave_fd, libc::TIOCSCTTY, 0) < 0 { + return Err(std::io::Error::last_os_error()); + } + } else { + if libc::setpgid(0, 0) < 0 { + return Err(std::io::Error::last_os_error()); + } } // Drop privileges before applying sandbox restrictions. @@ -862,14 +955,28 @@ impl ProcessHandle { } } - let child = cmd.spawn().into_diagnostic()?; + let mut child = cmd.spawn().into_diagnostic()?; let pid = child.id().unwrap_or(0); #[cfg(target_os = "linux")] managed_children::register(pid); debug!(pid, program, "Process spawned"); - Ok(Self { child, pid }) + let io = if let Some(master) = pty_master { + ProcessIo::Pty(master) + } else { + ProcessIo::Pipes { + stdin: child.stdin.take().expect("canonical stdin must be piped"), + stdout: child.stdout.take().expect("canonical stdout must be piped"), + stderr: child.stderr.take().expect("canonical stderr must be piped"), + } + }; + + Ok(Self { + child, + pid, + io: Some(io), + }) } /// Get the process ID. @@ -878,6 +985,11 @@ impl ProcessHandle { self.pid } + /// Transfer retained stdio to the main-session multiplexer. + pub fn take_io(&mut self) -> ProcessIo { + self.io.take().expect("canonical process I/O already taken") + } + /// Wait for the process to exit. /// /// # Errors @@ -891,6 +1003,16 @@ impl ProcessHandle { Ok(ProcessStatus::from(status)) } + /// Observe an already-terminated child without blocking. + pub fn try_wait(&mut self) -> std::io::Result> { + let status = self.child.try_wait()?; + if status.is_some() { + #[cfg(target_os = "linux")] + managed_children::unregister(self.pid); + } + Ok(status.map(ProcessStatus::from)) + } + /// Send a signal to the process. /// /// # Errors @@ -2150,6 +2272,12 @@ pub struct ProcessStatus { } impl ProcessStatus { + /// Get the conventional exit code when the process exited normally. + #[must_use] + pub const fn exit_code(&self) -> Option { + self.code + } + /// Get the exit code, or 128 + signal number if killed by signal. #[must_use] pub fn code(&self) -> i32 { diff --git a/crates/openshell-supervisor-process/src/run.rs b/crates/openshell-supervisor-process/src/run.rs index 91e56b7ec8..47eec7cbfe 100644 --- a/crates/openshell-supervisor-process/src/run.rs +++ b/crates/openshell-supervisor-process/src/run.rs @@ -13,6 +13,7 @@ use miette::{IntoDiagnostic, Result}; use std::sync::Arc; use std::sync::atomic::{AtomicBool, AtomicU32, Ordering}; use std::time::Duration; +use std::time::{SystemTime, UNIX_EPOCH}; use tokio::time::timeout; use tracing::info; @@ -39,6 +40,11 @@ use crate::process::{ ResolvedWorkspace, }; +pub type SidecarExitReport = ( + openshell_core::proto::MainProcessExit, + tokio::sync::oneshot::Sender>, +); + fn ocsf_ctx() -> &'static openshell_ocsf::SandboxContext { openshell_ocsf::ctx::ctx() } @@ -55,6 +61,7 @@ pub async fn run_process( program: &str, args: &[String], workspace: ResolvedWorkspace, + main_workdir: Option, timeout_secs: u64, interactive: bool, sandbox_id: Option<&str>, @@ -65,7 +72,8 @@ pub async fn run_process( resolved_process_identity: ResolvedProcessIdentity, enforcement_mode: ProcessEnforcementMode, entrypoint_pid: Arc, - entrypoint_started_tx: Option>, + entrypoint_started_tx: Option>, + sidecar_exit_tx: Option>, provider_credentials: ProviderCredentialState, provider_env: std::collections::HashMap, ca_file_paths: Option<(std::path::PathBuf, std::path::PathBuf)>, @@ -219,6 +227,40 @@ pub async fn run_process( #[cfg(not(target_os = "linux"))] let ssh_netns_fd: Option = None; + #[cfg(target_os = "linux")] + let mut handle = ProcessHandle::spawn( + program, + args, + &workspace, + main_workdir.as_deref(), + interactive, + policy, + resolved_process_identity, + enforcement_mode, + netns, + ca_file_paths.as_ref(), + &provider_env, + )?; + + #[cfg(not(target_os = "linux"))] + let mut handle = ProcessHandle::spawn( + program, + args, + &workspace, + main_workdir.as_deref(), + interactive, + policy, + resolved_process_identity, + enforcement_mode, + ca_file_paths.as_ref(), + &provider_env, + )?; + + let main_pid = handle.pid(); + let main_session = crate::main_session::MainSession::new(handle.take_io(), main_pid); + let main_generation = uuid::Uuid::new_v4().to_string(); + let main_started_at_ms = current_time_ms(); + // SSH-spawned shells get http_proxy=http://: exported into // their env so cooperative tools (curl, npm, Node) route through the // CONNECT proxy. Linux uses the netns host_ip; on other targets fall back @@ -236,6 +278,7 @@ pub async fn run_process( let netns_fd = ssh_netns_fd; let ca_paths = ca_file_paths.clone(); let provider_credentials_clone = provider_credentials.clone(); + let main_session_clone = Arc::clone(&main_session); let user_env_clone: std::collections::HashMap = std::env::var(openshell_core::sandbox_env::USER_ENVIRONMENT) .ok() @@ -258,6 +301,7 @@ pub async fn run_process( resolved_process_identity, enforcement_mode, shared_ssh_socket, + main_session_clone, ) .await { @@ -303,55 +347,39 @@ pub async fn run_process( } let supervisor_terminating = Arc::new(AtomicBool::new(false)); + // A canonical process may have completed while the SSH socket was being + // prepared. Never open a readiness-bearing supervisor session for a child + // that is already terminal. + let early_exit = handle.try_wait().into_diagnostic()?; // Spawn the persistent supervisor session if we have a gateway endpoint // and sandbox identity. The session provides relay channels for SSH // connect and ExecSandbox through the gateway. - if let (Some(endpoint), Some(id), Some(socket)) = - (openshell_endpoint, sandbox_id, ssh_socket_path.as_ref()) + let supervisor_session_task = if early_exit.is_none() + && let (Some(endpoint), Some(id), Some(socket)) = + (openshell_endpoint, sandbox_id, ssh_socket_path.as_ref()) { - crate::supervisor_session::spawn( + let task = crate::supervisor_session::spawn( endpoint.to_string(), id.to_string(), socket.clone(), ssh_netns_fd, None, Arc::clone(&supervisor_terminating), + main_generation.clone(), ); info!("supervisor session task spawned"); - } - - #[cfg(target_os = "linux")] - let mut handle = ProcessHandle::spawn( - program, - args, - &workspace, - interactive, - policy, - resolved_process_identity, - enforcement_mode, - netns, - ca_file_paths.as_ref(), - &provider_env, - )?; - - #[cfg(not(target_os = "linux"))] - let mut handle = ProcessHandle::spawn( - program, - args, - &workspace, - interactive, - policy, - resolved_process_identity, - enforcement_mode, - ca_file_paths.as_ref(), - &provider_env, - )?; + Some(task) + } else { + None + }; // Store the entrypoint PID so the proxy can resolve TCP peer identity entrypoint_pid.store(handle.pid(), Ordering::Release); - if let Some(tx) = entrypoint_started_tx { - let _ = tx.send(handle.pid()); + if early_exit.is_none() + && let Some(tx) = entrypoint_started_tx + { + let _ = tx.send((handle.pid(), main_generation.clone())); } ocsf_emit!( ProcessActivityBuilder::new(ocsf_ctx()) @@ -366,12 +394,15 @@ pub async fn run_process( .build() ); - let outcome = + let outcome = if let Some(status) = early_exit { + ProcessWaitOutcome::Exited(status) + } else { wait_for_process_exit_or_shutdown(&mut handle, timeout_secs, &supervisor_terminating) - .await?; + .await? + }; - let status = match outcome { - ProcessWaitOutcome::Exited(status) => status, + let (exit_code, signal, rendered_code) = match outcome { + ProcessWaitOutcome::Exited(status) => (status.exit_code(), status.signal(), status.code()), ProcessWaitOutcome::TimedOut => { ocsf_emit!( ProcessActivityBuilder::new(ocsf_ctx()) @@ -383,7 +414,7 @@ pub async fn run_process( .message("Process timed out, killing") .build() ); - return Ok(124); // Standard timeout exit code + (Some(124), None, 124) } ProcessWaitOutcome::ShutdownSignal { signal, status } => { info!( @@ -391,10 +422,11 @@ pub async fn run_process( exit_code = status.code(), "Entrypoint exited after supervisor shutdown signal" ); - status + (status.exit_code(), status.signal(), status.code()) } }; supervisor_terminating.store(true, Ordering::Release); + main_session.finish(rendered_code).await; ocsf_emit!( ProcessActivityBuilder::new(ocsf_ctx()) @@ -403,12 +435,70 @@ pub async fn run_process( .disposition(DispositionId::Allowed) .severity(SeverityId::Informational) .status(StatusId::Success) - .exit_code(status.code()) - .message(format!("Process exited with code {}", status.code())) + .exit_code(rendered_code) + .message(format!("Process exited with code {rendered_code}")) .build() ); - Ok(status.code()) + if let Some(task) = supervisor_session_task { + task.abort(); + } + let exit = openshell_core::proto::MainProcessExit { + generation: main_generation.clone(), + exit_code, + signal, + started_at_ms: main_started_at_ms, + finished_at_ms: current_time_ms(), + }; + if let Some(tx) = sidecar_exit_tx { + let (ack_tx, ack_rx) = tokio::sync::oneshot::channel(); + tx.send((exit, ack_tx)) + .await + .map_err(|_| miette::miette!("sidecar exit reporter closed"))?; + ack_rx + .await + .map_err(|_| miette::miette!("sidecar exit reporter dropped acknowledgement"))? + .map_err(|error| miette::miette!(error))?; + } else if let (Some(endpoint), Some(id)) = (openshell_endpoint, sandbox_id) { + report_main_process_exit_until_ack(endpoint, id, &main_generation, exit).await; + info!(generation = %main_generation, "main-process exit acknowledged"); + } + + Ok(rendered_code) +} + +async fn report_main_process_exit_until_ack( + endpoint: &str, + sandbox_id: &str, + generation: &str, + exit: openshell_core::proto::MainProcessExit, +) { + let mut retry_delay = Duration::from_millis(250); + loop { + match crate::supervisor_session::report_main_process_exit( + endpoint, + sandbox_id, + generation, + exit.clone(), + ) + .await + { + Ok(()) => return, + Err(error) => { + tracing::warn!(%error, "main-process exit report failed; retrying"); + tokio::time::sleep(retry_delay).await; + retry_delay = (retry_delay * 2).min(Duration::from_secs(2)); + } + } + } +} + +fn current_time_ms() -> i64 { + SystemTime::now() + .duration_since(UNIX_EPOCH) + .map_or(0, |duration| { + i64::try_from(duration.as_millis()).unwrap_or(i64::MAX) + }) } enum ProcessWaitOutcome { @@ -486,13 +576,13 @@ fn signal_entrypoint_for_shutdown(_pid: u32, _signal: &'static str) {} #[cfg(unix)] fn signal_pid(pid: u32, signal: nix::sys::signal::Signal, reason: &'static str) { let raw_pid = i32::try_from(pid).unwrap_or(i32::MAX); - if let Err(error) = nix::sys::signal::kill(nix::unistd::Pid::from_raw(raw_pid), signal) { + if let Err(error) = nix::sys::signal::kill(nix::unistd::Pid::from_raw(-raw_pid), signal) { tracing::warn!( pid, signal = ?signal, reason, error = %error, - "failed to signal entrypoint process" + "failed to signal entrypoint process group" ); } } diff --git a/crates/openshell-supervisor-process/src/ssh.rs b/crates/openshell-supervisor-process/src/ssh.rs index 07302da953..3459656514 100644 --- a/crates/openshell-supervisor-process/src/ssh.rs +++ b/crates/openshell-supervisor-process/src/ssh.rs @@ -4,6 +4,7 @@ //! Embedded SSH server for sandbox access. use crate::child_env; +use crate::main_session::{MainOutput, MainSession}; #[cfg(target_os = "linux")] use crate::managed_children; use crate::process::{ @@ -22,7 +23,7 @@ use openshell_ocsf::{ }; use russh::keys::{Algorithm, PrivateKey}; use russh::server::{Auth, ChannelOpenHandle, Handle, Session}; -use russh::{ChannelId, ChannelOpenFailure}; +use russh::{ChannelId, ChannelOpenFailure, Sig}; use std::collections::HashMap; use std::io::{Read, Write}; use std::os::fd::{AsRawFd, RawFd}; @@ -120,6 +121,7 @@ pub async fn run_ssh_server( resolved_identity: ResolvedProcessIdentity, enforcement_mode: ProcessEnforcementMode, shared_socket: bool, + main_session: Arc, ) -> Result<()> { let (listener, config, ca_paths) = match ssh_server_init( &listen_path, @@ -150,6 +152,7 @@ pub async fn run_ssh_server( let ca_paths = ca_paths.clone(); let provider_credentials = provider_credentials.clone(); let user_environment = user_environment.clone(); + let main_session = Arc::clone(&main_session); tokio::spawn(async move { if let Err(err) = handle_connection( @@ -164,6 +167,7 @@ pub async fn run_ssh_server( user_environment, resolved_identity, enforcement_mode, + main_session, ) .await { @@ -193,6 +197,7 @@ async fn handle_connection( user_environment: HashMap, resolved_identity: ResolvedProcessIdentity, enforcement_mode: ProcessEnforcementMode, + main_session: Arc, ) -> Result<()> { // Access is gated by the Unix-socket filesystem permissions (root-only), // not by an application-level preface. The supervisor bridges the @@ -218,6 +223,7 @@ async fn handle_connection( user_environment, resolved_identity, enforcement_mode, + main_session, ); russh::server::run_stream(config, stream, handler) .await @@ -233,9 +239,32 @@ async fn handle_connection( /// sftp, etc.). #[derive(Default)] struct ChannelState { - input_sender: Option>>, + input_sender: Option, pty_master: Option, pty_request: Option, + main_input_owner: Option, + main_attached: bool, + main_read_only: bool, + main_output_task: Option, +} + +enum InputSender { + Process(mpsc::Sender>), + Main(tokio::sync::mpsc::Sender>), +} + +impl InputSender { + fn send(&self, data: Vec) -> Result<(), &'static str> { + match self { + Self::Process(sender) => sender.send(data).map_err(|_| "process stdin closed"), + Self::Main(sender) => sender.try_send(data).map_err(|error| match error { + tokio::sync::mpsc::error::TrySendError::Full(_) => "canonical stdin buffer is full", + tokio::sync::mpsc::error::TrySendError::Closed(_) => { + "canonical process stdin closed" + } + }), + } + } } struct SshHandler { @@ -248,9 +277,23 @@ struct SshHandler { user_environment: HashMap, resolved_identity: ResolvedProcessIdentity, enforcement_mode: ProcessEnforcementMode, + main_session: Arc, channels: HashMap, } +impl Drop for SshHandler { + fn drop(&mut self) { + for state in self.channels.values_mut() { + if let Some(owner) = state.main_input_owner.take() { + self.main_session.release_input(owner); + } + if let Some(task) = state.main_output_task.take() { + task.abort(); + } + } + } +} + impl SshHandler { #[allow(clippy::too_many_arguments)] fn new( @@ -263,6 +306,7 @@ impl SshHandler { user_environment: HashMap, resolved_identity: ResolvedProcessIdentity, enforcement_mode: ProcessEnforcementMode, + main_session: Arc, ) -> Self { Self { policy, @@ -274,6 +318,7 @@ impl SshHandler { user_environment, resolved_identity, enforcement_mode, + main_session, channels: HashMap::new(), } } @@ -315,7 +360,14 @@ impl russh::server::Handler for SshHandler { channel: ChannelId, _session: &mut Session, ) -> Result<(), Self::Error> { - self.channels.remove(&channel); + if let Some(state) = self.channels.remove(&channel) { + if let Some(owner) = state.main_input_owner { + self.main_session.release_input(owner); + } + if let Some(task) = state.main_output_task { + task.abort(); + } + } Ok(()) } @@ -442,7 +494,10 @@ impl russh::server::Handler for SshHandler { warn!("window_change_request on unknown channel {channel:?}"); return Ok(()); }; - if let Some(master) = state.pty_master.as_ref() { + if state.main_attached { + self.main_session + .resize(col_width, row_height, pixel_width, pixel_height); + } else if let Some(master) = state.pty_master.as_ref() { let winsize = Winsize { ws_row: to_u16(row_height.max(1)), ws_col: to_u16(col_width.max(1)), @@ -493,7 +548,86 @@ impl russh::server::Handler for SshHandler { name: &str, session: &mut Session, ) -> Result<(), Self::Error> { - if name == "sftp" { + if name == "openshell-main" { + let state = self.channels.get_mut(&channel).ok_or_else(|| { + anyhow::anyhow!("subsystem_request on unknown channel {channel:?}") + })?; + if let Some(pty) = state.pty_request.take() { + self.main_session.resize( + pty.col_width, + pty.row_height, + pty.pixel_width, + pty.pixel_height, + ); + } + let (input, input_warning) = if state.main_read_only { + (None, None) + } else { + match self.main_session.acquire_input() { + Ok((owner, input)) => { + state.main_input_owner = Some(owner); + (Some(InputSender::Main(input)), None) + } + Err(error) => { + warn!(%error, "main process input lease unavailable; attaching read-only"); + (None, Some(error)) + } + } + }; + state.main_attached = true; + state.input_sender = input; + let (replay, mut output) = self.main_session.subscribe(); + let handle = session.handle(); + session.channel_success(channel)?; + if let Some(error) = input_warning { + let _ = handle + .extended_data( + channel, + 1, + format!("openshell: {error}; attached read-only\n").into_bytes(), + ) + .await; + } + let output_task = tokio::spawn(async move { + let mut replay_exited = false; + for event in replay { + replay_exited |= matches!(event, MainOutput::Exit(_)); + send_main_output(&handle, channel, event).await; + } + if replay_exited { + return; + } + loop { + match output.recv().await { + Ok(event) => { + let exited = matches!(event, MainOutput::Exit(_)); + send_main_output(&handle, channel, event).await; + if exited { + break; + } + } + Err(tokio::sync::broadcast::error::RecvError::Lagged(skipped)) => { + let _ = handle + .extended_data( + channel, + 1, + format!( + "openshell: attachment fell behind by {skipped} output chunks; reconnect for buffered output\n" + ) + .into_bytes(), + ) + .await; + let _ = handle.close(channel).await; + break; + } + Err(tokio::sync::broadcast::error::RecvError::Closed) => break, + } + } + }); + if let Some(state) = self.channels.get_mut(&channel) { + state.main_output_task = Some(output_task.abort_handle()); + } + } else if name == "sftp" { session.channel_success(channel)?; // sftp-server speaks the SFTP binary protocol over stdin/stdout, // which is exactly what spawn_pipe_exec wires up. This enables @@ -516,7 +650,7 @@ impl russh::server::Handler for SshHandler { let state = self.channels.get_mut(&channel).ok_or_else(|| { anyhow::anyhow!("subsystem_request on unknown channel {channel:?}") })?; - state.input_sender = Some(input_sender); + state.input_sender = Some(InputSender::Process(input_sender)); } else { ocsf_emit!( SshActivityBuilder::new(openshell_ocsf::ctx::ctx()) @@ -542,7 +676,12 @@ impl russh::server::Handler for SshHandler { // Accept the env request so the client knows we handled it, but we // don't actually propagate the variables — the sandbox environment is // controlled via policy. We must reply so VSCode doesn't stall. - let _ = (variable_name, variable_value); + if variable_name == "OPENSHELL_MAIN_READ_ONLY" + && variable_value == "1" + && let Some(state) = self.channels.get_mut(&channel) + { + state.main_read_only = true; + } session.channel_success(channel)?; Ok(()) } @@ -551,14 +690,24 @@ impl russh::server::Handler for SshHandler { &mut self, channel: ChannelId, data: &[u8], - _session: &mut Session, + session: &mut Session, ) -> Result<(), Self::Error> { let Some(state) = self.channels.get(&channel) else { warn!("data on unknown channel {channel:?}"); return Ok(()); }; - if let Some(sender) = state.input_sender.as_ref() { - let _ = sender.send(data.to_vec()); + if let Some(sender) = state.input_sender.as_ref() + && let Err(error) = sender.send(data.to_vec()) + { + let handle = session.handle(); + let _ = handle + .extended_data( + channel, + 1, + format!("openshell: {error}; closing attachment\n").into_bytes(), + ) + .await; + let _ = handle.close(channel).await; } Ok(()) } @@ -573,12 +722,64 @@ impl russh::server::Handler for SshHandler { // is essential for commands like `cat | tar xf -` which need // stdin EOF to know the input stream is complete. if let Some(state) = self.channels.get_mut(&channel) { + if state.main_attached + && let Some(owner) = state.main_input_owner.take() + { + self.main_session.release_input(owner); + } state.input_sender.take(); } else { warn!("channel_eof on unknown channel {channel:?}"); } Ok(()) } + + async fn signal( + &mut self, + channel: ChannelId, + signal: Sig, + _session: &mut Session, + ) -> Result<(), Self::Error> { + if !self + .channels + .get(&channel) + .is_some_and(|state| state.main_attached) + { + return Ok(()); + } + let signal = match signal { + Sig::HUP => Some(nix::sys::signal::Signal::SIGHUP), + Sig::INT => Some(nix::sys::signal::Signal::SIGINT), + Sig::KILL => Some(nix::sys::signal::Signal::SIGKILL), + Sig::QUIT => Some(nix::sys::signal::Signal::SIGQUIT), + Sig::TERM => Some(nix::sys::signal::Signal::SIGTERM), + _ => None, + }; + if let Some(signal) = signal + && let Err(error) = self.main_session.signal_group(signal) + { + warn!(%error, ?signal, "failed to signal canonical main process group"); + } + Ok(()) + } +} + +async fn send_main_output(handle: &Handle, channel: ChannelId, event: MainOutput) { + match event { + MainOutput::Stdout(data) => { + let _ = handle.data(channel, data).await; + } + MainOutput::Stderr(data) => { + let _ = handle.extended_data(channel, 1, data).await; + } + MainOutput::Exit(code) => { + let _ = handle.eof(channel).await; + let _ = handle + .exit_status_request(channel, code.max(0).unsigned_abs()) + .await; + let _ = handle.close(channel).await; + } + } } impl SshHandler { @@ -612,7 +813,7 @@ impl SshHandler { self.enforcement_mode, )?; state.pty_master = Some(pty_master); - state.input_sender = Some(input_sender); + state.input_sender = Some(InputSender::Process(input_sender)); } else { // No PTY requested — use plain pipes so stdout/stderr are // separate and output has clean LF line endings. This is the @@ -631,7 +832,7 @@ impl SshHandler { self.resolved_identity, self.enforcement_mode, )?; - state.input_sender = Some(input_sender); + state.input_sender = Some(InputSender::Process(input_sender)); } Ok(()) } @@ -1665,11 +1866,11 @@ mod tests { let (tx_b, rx_b) = mpsc::channel::>(); let mut state_a = ChannelState { - input_sender: Some(tx_a), + input_sender: Some(InputSender::Process(tx_a)), ..Default::default() }; let state_b = ChannelState { - input_sender: Some(tx_b), + input_sender: Some(InputSender::Process(tx_b)), ..Default::default() }; @@ -2012,7 +2213,9 @@ mod tests { /// The handler gets `netns_fd: None` so `connect_in_netns` performs a plain /// TCP connect, making the forwarding path reachable without a network /// namespace. - async fn authenticated_test_client() -> russh::client::Handle { + async fn authenticated_test_client_with_main( + main_session: Arc, + ) -> russh::client::Handle { // Scoped so the `!Send` ThreadRng is dropped before the first await. let host_key = { let mut rng = rand::rng(); @@ -2034,6 +2237,7 @@ mod tests { HashMap::new(), ResolvedProcessIdentity::default(), ProcessEnforcementMode::NetworkOnly, + main_session, ); let (server_stream, client_stream) = tokio::io::duplex(64 * 1024); @@ -2065,6 +2269,71 @@ mod tests { client } + async fn authenticated_test_client() -> russh::client::Handle { + authenticated_test_client_with_main(MainSession::inert()).await + } + + #[tokio::test] + async fn abrupt_transport_drop_releases_main_input_lease() { + let main_session = MainSession::inert(); + let client = authenticated_test_client_with_main(Arc::clone(&main_session)).await; + let channel = client.channel_open_session().await.expect("open session"); + channel + .request_subsystem(true, "openshell-main") + .await + .expect("attach main subsystem"); + tokio::time::timeout(Duration::from_secs(1), async { + loop { + match main_session.acquire_input() { + Err(_) => break, + Ok((owner, _)) => main_session.release_input(owner), + } + tokio::task::yield_now().await; + } + }) + .await + .expect("main subsystem should acquire canonical input lease"); + + drop(channel); + drop(client); + tokio::time::timeout(Duration::from_secs(1), async { + loop { + if main_session.acquire_input().is_ok() { + break; + } + tokio::task::yield_now().await; + } + }) + .await + .expect("handler drop should release canonical input lease"); + } + + #[tokio::test] + async fn main_subsystem_applies_initial_pty_dimensions() { + let (main_session, _slave) = MainSession::terminal_for_test(); + let client = authenticated_test_client_with_main(Arc::clone(&main_session)).await; + let channel = client.channel_open_session().await.expect("open session"); + channel + .request_pty(true, "xterm-256color", 200, 60, 1600, 900, &[]) + .await + .expect("request PTY"); + channel + .request_subsystem(true, "openshell-main") + .await + .expect("attach main subsystem"); + + tokio::time::timeout(Duration::from_secs(1), async { + loop { + if main_session.terminal_size_for_test() == (200, 60) { + break; + } + tokio::task::yield_now().await; + } + }) + .await + .expect("main subsystem should apply the initial PTY dimensions"); + } + #[tokio::test] async fn direct_tcpip_rejects_non_loopback_destination() { let client = authenticated_test_client().await; diff --git a/crates/openshell-supervisor-process/src/supervisor_session.rs b/crates/openshell-supervisor-process/src/supervisor_session.rs index 6cdc9e7d6c..84497b24fe 100644 --- a/crates/openshell-supervisor-process/src/supervisor_session.rs +++ b/crates/openshell-supervisor-process/src/supervisor_session.rs @@ -19,9 +19,9 @@ use std::time::Duration; use openshell_core::proto::open_shell_client::OpenShellClient; use openshell_core::proto::{ - GatewayMessage, RelayFrame, RelayInit, RelayOpen, RelayOpenResult, SupervisorHeartbeat, - SupervisorHello, SupervisorMessage, TcpRelayTarget, gateway_message, relay_open, - supervisor_message, + GatewayMessage, MainProcessExit, RelayFrame, RelayInit, RelayOpen, RelayOpenResult, + SupervisorHeartbeat, SupervisorHello, SupervisorMessage, TcpRelayTarget, gateway_message, + relay_open, supervisor_message, }; use openshell_ocsf::{ ActivityId, ConnectionInfo, Endpoint, NetworkActivityBuilder, OcsfEvent, SandboxContext, @@ -281,6 +281,7 @@ pub fn spawn( netns_fd: Option, expected_ssh_peer_pid: Option, terminating: Arc, + instance_id: String, ) -> tokio::task::JoinHandle<()> { tokio::spawn(run_session_loop( endpoint, @@ -289,6 +290,7 @@ pub fn spawn( netns_fd, expected_ssh_peer_pid, terminating, + instance_id, )) } @@ -299,6 +301,7 @@ async fn run_session_loop( netns_fd: Option, expected_ssh_peer_pid: Option, terminating: Arc, + instance_id: String, ) { let mut backoff = INITIAL_BACKOFF; let mut attempt: u64 = 0; @@ -313,6 +316,7 @@ async fn run_session_loop( netns_fd, expected_ssh_peer_pid, Arc::clone(&terminating), + &instance_id, ) .await { @@ -344,6 +348,7 @@ async fn run_single_session( netns_fd: Option, expected_ssh_peer_pid: Option, terminating: Arc, + instance_id: &str, ) -> Result<(), Box> { // Connect to the gateway. The same `Channel` is used for both the // long-lived control stream and all data-plane `RelayStream` calls, so @@ -359,11 +364,11 @@ async fn run_single_session( let outbound = tokio_stream::wrappers::ReceiverStream::new(rx); // Send hello as the first message. - let instance_id = uuid::Uuid::new_v4().to_string(); tx.send(SupervisorMessage { payload: Some(supervisor_message::Payload::Hello(SupervisorHello { sandbox_id: sandbox_id.to_string(), - instance_id: instance_id.clone(), + instance_id: instance_id.to_string(), + exit_report_only: false, })), }) .await @@ -443,6 +448,56 @@ async fn run_single_session( } } +/// Report the canonical process result on a short-lived authenticated session +/// and wait until the gateway acknowledges durable handling. +pub async fn report_main_process_exit( + endpoint: &str, + sandbox_id: &str, + instance_id: &str, + exit: MainProcessExit, +) -> Result<(), Box> { + let channel = grpc_client::connect_channel_pub(endpoint) + .await + .map_err(|error| format!("connect failed: {error}"))?; + let mut client = OpenShellClient::new(channel); + let (tx, rx) = mpsc::channel::(4); + tx.send(SupervisorMessage { + payload: Some(supervisor_message::Payload::Hello(SupervisorHello { + sandbox_id: sandbox_id.to_string(), + instance_id: instance_id.to_string(), + exit_report_only: true, + })), + }) + .await + .map_err(|_| "failed to queue supervisor hello")?; + let response = client + .connect_supervisor(tokio_stream::wrappers::ReceiverStream::new(rx)) + .await?; + let mut inbound = response.into_inner(); + let accepted = inbound + .message() + .await? + .and_then(|message| message.payload) + .is_some_and(|payload| matches!(payload, gateway_message::Payload::SessionAccepted(_))); + if !accepted { + return Err("gateway did not accept exit-report session".into()); + } + let generation = exit.generation.clone(); + tx.send(SupervisorMessage { + payload: Some(supervisor_message::Payload::MainProcessExit(exit)), + }) + .await + .map_err(|_| "failed to queue main-process exit")?; + while let Some(message) = inbound.message().await? { + if let Some(gateway_message::Payload::MainProcessExitAck(ack)) = message.payload + && ack.generation == generation + { + return Ok(()); + } + } + Err("gateway closed before acknowledging main-process exit".into()) +} + struct GatewayMessageContext<'a> { sandbox_id: &'a str, ssh_socket_path: &'a std::path::Path, diff --git a/docs/observability/accessing-logs.mdx b/docs/observability/accessing-logs.mdx index e96dfeab2f..4b755f74cc 100644 --- a/docs/observability/accessing-logs.mdx +++ b/docs/observability/accessing-logs.mdx @@ -41,19 +41,22 @@ For durable log storage, use the log files inside the sandbox or enable [OCSF JS ## Direct Filesystem Access -Use `openshell sandbox connect` to open a shell inside the sandbox and read the log files directly: +Start an independent shell with `sandbox exec` to read log files directly: ```text -openshell sandbox connect my-sandbox +openshell sandbox exec --name my-sandbox --tty -- /bin/bash -l sandbox@my-sandbox:~$ cat /var/log/openshell.2026-04-01.log ``` -You can also run a one-off command without an interactive shell: +Or run a one-off command without an interactive shell: ```shell -openshell sandbox connect my-sandbox -- cat /var/log/openshell.2026-04-01.log +openshell sandbox exec --name my-sandbox -- cat /var/log/openshell.2026-04-01.log ``` +`sandbox connect` attaches to the sandbox's existing canonical main process; it +does not start a new shell. + The log files inside the sandbox contain the complete record, including events that the gRPC push channel can drop under load. The push channel is bounded and drops events rather than blocking. ## Filtering by Event Type diff --git a/docs/reference/sandbox-compute-drivers.mdx b/docs/reference/sandbox-compute-drivers.mdx index 897e780c39..18457333df 100644 --- a/docs/reference/sandbox-compute-drivers.mdx +++ b/docs/reference/sandbox-compute-drivers.mdx @@ -18,6 +18,12 @@ Delete remains independent and removes compute plus driver-owned persistent state. While a sandbox is stopped, gateway access paths and exposed services remain unavailable. +The gateway forwards one exact, persisted main-process specification to every +driver. Drivers serialize that specification in +`OPENSHELL_MAIN_PROCESS_SPEC`; they do not install an idle `sleep` workload or +reconstruct argv with shell parsing. Runtime restart policies are disabled so +an exited canonical process remains a terminal sandbox error. + ## Configure a Compute Driver Configure the compute driver on the gateway. Current releases accept one driver per gateway. Set `compute_drivers` in the gateway TOML file: diff --git a/docs/sandboxes/manage-sandboxes.mdx b/docs/sandboxes/manage-sandboxes.mdx index abd95d130a..27a8b6d705 100644 --- a/docs/sandboxes/manage-sandboxes.mdx +++ b/docs/sandboxes/manage-sandboxes.mdx @@ -20,6 +20,20 @@ Create a sandbox with a single command. For example, to create a sandbox with Cl openshell sandbox create -- claude ``` +The trailing command is the sandbox's canonical main process. OpenShell starts +it once and attaches your terminal to it. With no trailing command, OpenShell +starts `/bin/bash -l` in a retained pseudo-terminal. Add `--detach` to create +the sandbox without attaching: + +```shell +openshell sandbox create --name worker --detach -- ./worker +``` + +`--upload` cannot yet be combined with a trailing main command because uploads +finish after the canonical process starts. Create a scratch sandbox, upload the +files, then launch the workload with `sandbox exec`, or build the files into the +sandbox image. + For automation, use `--output json` or `--output yaml` to get machine-readable sandbox metadata after creation: ```shell @@ -142,12 +156,17 @@ For default policy coverage by agent, refer to [Default Policy](/reference/defau ## Connect to a Sandbox -Open an SSH session into a running sandbox: +Attach to the canonical main process in a running sandbox: ```shell openshell sandbox connect my-sandbox ``` +Disconnecting does not stop the process or close its stdin. A later `connect` +attaches to the same process generation and replays up to 1 MiB of recent +output. One attachment owns stdin at a time. Use `sandbox exec --tty -- +/bin/bash -l` when you want a new independent shell instead. + Launch VS Code or Cursor directly into the sandbox workspace: ```shell @@ -477,7 +496,7 @@ Every sandbox moves through a defined set of phases: | Stopping | The gateway accepted a stop request and is stopping compute while retaining persistent state. | | Stopped | Compute is stopped and access is unavailable. The sandbox record and driver-owned persistent workspace remain. | | Starting | Compute is starting. The sandbox becomes usable only after a fresh supervisor session connects. | -| Error | Something went wrong during provisioning or execution. Check logs with `openshell logs` for details. | +| Error | Provisioning failed or the canonical main process exited unexpectedly. Main-process exit is terminal even with exit code 0. Check logs with `openshell logs`. | | Deleting | The sandbox is being torn down. The system releases resources and purges credentials. | The compute backend can become ready before the sandbox supervisor connects to @@ -487,6 +506,9 @@ After a gateway restart, an existing sandbox can return to `Provisioning` temporarily while its supervisor reconnects. Wait for the phase to return to `Ready` before you connect to the sandbox or execute commands. +The gateway records a canonical main-process exit as `Ready=False` with reason +`MainProcessExited`. Compute runtimes do not automatically restart that process. + ## Sandbox Compute Drivers The gateway's configured compute driver determines how OpenShell creates each sandbox. The CLI workflow stays the same across drivers: you create, connect to, inspect, and delete sandboxes through the gateway API. diff --git a/docs/sandboxes/policies.mdx b/docs/sandboxes/policies.mdx index 8cb7398efc..020305a78d 100644 --- a/docs/sandboxes/policies.mdx +++ b/docs/sandboxes/policies.mdx @@ -121,7 +121,9 @@ Pass a policy YAML file when creating the sandbox: openshell sandbox create --policy ./my-policy.yaml -- claude ``` -`openshell sandbox create` keeps the sandbox running after the initial command exits, which is useful when you plan to iterate on the policy. Add `--no-keep` if you want the sandbox deleted automatically instead. +The trailing command is the sandbox's canonical main process. If it exits, the +sandbox enters `Error`; use `sandbox exec` for one-shot commands that should not +define sandbox health. To avoid passing `--policy` every time, set a default policy with an environment variable: diff --git a/e2e/rust/src/harness/sandbox.rs b/e2e/rust/src/harness/sandbox.rs index 3475353041..1ee676d839 100644 --- a/e2e/rust/src/harness/sandbox.rs +++ b/e2e/rust/src/harness/sandbox.rs @@ -51,11 +51,12 @@ pub struct SandboxGuard { } impl SandboxGuard { - /// Create a sandbox that runs a command to completion (no `--keep`). + /// Create a persistent scratch sandbox and optionally run a command in it. /// - /// Captures the full CLI output and parses the sandbox name from it. - /// The sandbox is created synchronously (the CLI blocks until the command - /// finishes). + /// Arguments before `--` are forwarded to `sandbox create`; arguments after + /// `--` are run with `sandbox exec`. This keeps generic E2E tests focused on + /// the behavior of their one-shot payload now that a trailing create command + /// is the sandbox's canonical main process and its exit is terminal. /// /// # Arguments /// @@ -67,10 +68,19 @@ impl SandboxGuard { /// Returns an error if the CLI exits with a non-zero status or the sandbox /// name cannot be parsed from the output. pub async fn create(args: &[&str]) -> Result { + let separator = args.iter().position(|arg| *arg == "--"); + let (create_args, command) = separator.map_or((args, &[][..]), |index| { + (&args[..index], &args[index + 1..]) + }); + let mut cmd = openshell_cmd(); - cmd.arg("sandbox").arg("create"); - for arg in args { - cmd.arg(arg); + cmd.arg("sandbox").arg("create").arg("--detach"); + for arg in create_args { + // `--no-keep` described the old disposable-exec create flow and + // conflicts with the detached scratch sandbox used by this helper. + if *arg != "--no-keep" { + cmd.arg(arg); + } } cmd.stdout(Stdio::piped()).stderr(Stdio::piped()); @@ -94,20 +104,32 @@ impl SandboxGuard { format!("could not parse sandbox name from create output:\n{combined}") })?; - Ok(Self { + let mut guard = Self { name, create_output: combined, child: None, cleaned_up: false, - }) + }; + + if !command.is_empty() { + match guard.exec(command).await { + Ok(exec_output) => guard.create_output.push_str(&exec_output), + Err(err) => { + guard.cleanup().await; + return Err(err); + } + } + } + + Ok(guard) } - /// Create a sandbox with `--keep` that runs a long-lived background - /// command. + /// Create a sandbox with a long-lived canonical main command and connect + /// to it in the background. /// - /// The CLI process runs in the background. This method polls its stdout - /// for `ready_marker` (a string the background command prints when it is - /// ready to accept work). Sandbox name is parsed from the output header. + /// Creation is detached because the harness captures output. This method + /// then runs `sandbox connect` and polls the retained main-process output + /// for `ready_marker`. /// /// # Arguments /// @@ -139,17 +161,44 @@ impl SandboxGuard { command: &[&str], ready_marker: &str, ) -> Result { - let mut cmd = openshell_cmd(); - cmd.arg("sandbox").arg("create").arg("--keep"); + let mut create_cmd = openshell_cmd(); + create_cmd.arg("sandbox").arg("create").arg("--detach"); for arg in create_args { - cmd.arg(arg); + create_cmd.arg(arg); } - cmd.arg("--").args(command); - cmd.stdout(Stdio::piped()).stderr(Stdio::piped()); + create_cmd.arg("--").args(command); + create_cmd.stdout(Stdio::piped()).stderr(Stdio::piped()); - let mut child = cmd - .spawn() + let create_output = timeout(SANDBOX_READY_TIMEOUT, create_cmd.output()) + .await + .map_err(|_| format!("sandbox create timed out after {SANDBOX_READY_TIMEOUT:?}"))? .map_err(|e| format!("failed to spawn openshell: {e}"))?; + let create_stdout = String::from_utf8_lossy(&create_output.stdout).to_string(); + let create_stderr = String::from_utf8_lossy(&create_output.stderr).to_string(); + let create_combined = format!("{create_stdout}{create_stderr}"); + + if !create_output.status.success() { + return Err(format!( + "sandbox create failed (exit {:?}):\n{create_combined}", + create_output.status.code() + )); + } + + let sandbox_name = extract_sandbox_name(&create_combined).ok_or_else(|| { + format!("could not parse sandbox name from create output:\n{create_combined}") + })?; + + let mut connect_cmd = openshell_cmd(); + connect_cmd + .arg("sandbox") + .arg("connect") + .arg(&sandbox_name) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + + let mut child = connect_cmd + .spawn() + .map_err(|e| format!("failed to spawn openshell connect: {e}"))?; let stdout = child.stdout.take().expect("stdout must be piped"); let mut reader = BufReader::new(stdout).lines(); @@ -167,8 +216,7 @@ impl SandboxGuard { } }); - let mut accumulated = String::new(); - let mut name: Option = None; + let mut accumulated = create_combined; let mut ready = false; let poll_result = timeout(SANDBOX_READY_TIMEOUT, async { @@ -177,13 +225,6 @@ impl SandboxGuard { accumulated.push_str(&clean); accumulated.push('\n'); - // Try to extract the sandbox name from the header. - if name.is_none() - && let Some(n) = extract_sandbox_name(&accumulated) - { - name = Some(n); - } - // Check for the ready marker. if clean.contains(ready_marker) { ready = true; @@ -214,19 +255,11 @@ impl SandboxGuard { let _ = child.kill().await; let stderr_output = collect_stderr(); return Err(format!( - "sandbox create exited before ready marker '{ready_marker}' was seen.\n\ + "sandbox connect exited before ready marker '{ready_marker}' was seen.\n\ Stdout:\n{accumulated}\nStderr:\n{stderr_output}" )); } - let sandbox_name = name.ok_or_else(|| { - let stderr_output = collect_stderr(); - format!( - "could not parse sandbox name from create output:\n\ - Stdout:\n{accumulated}\nStderr:\n{stderr_output}" - ) - })?; - Ok(Self { name: sandbox_name, create_output: accumulated, @@ -235,11 +268,13 @@ impl SandboxGuard { }) } - /// Create a sandbox that runs a command, with `--upload` to pre-load files. + /// Create a detached scratch sandbox with pre-loaded files, then exec a + /// command in it. /// /// Equivalent to: /// ```text - /// openshell sandbox create --upload : [extra_args...] -- + /// openshell sandbox create --detach --upload : [extra_args...] + /// openshell sandbox exec -- /// ``` /// /// The `--no-git-ignore` flag is passed to avoid needing a git repository. @@ -265,11 +300,11 @@ impl SandboxGuard { command: &[&str], ) -> Result { let mut cmd = openshell_cmd(); - cmd.arg("sandbox").arg("create"); + cmd.arg("sandbox").arg("create").arg("--detach"); for (local, dest) in uploads { cmd.arg("--upload").arg(format!("{local}:{dest}")); } - cmd.arg("--no-git-ignore").arg("--").args(command); + cmd.arg("--no-git-ignore"); cmd.stdout(Stdio::piped()).stderr(Stdio::piped()); let output = timeout(SANDBOX_READY_TIMEOUT, cmd.output()) @@ -294,12 +329,22 @@ impl SandboxGuard { format!("could not parse sandbox name from create output:\n{combined}") })?; - Ok(Self { + let mut guard = Self { name, create_output: combined, child: None, cleaned_up: false, - }) + }; + + match guard.exec(command).await { + Ok(exec_output) => guard.create_output.push_str(&exec_output), + Err(err) => { + guard.cleanup().await; + return Err(err); + } + } + + Ok(guard) } /// Upload local files to the sandbox via `openshell sandbox upload`. diff --git a/e2e/rust/tests/local_driver_token_restart.rs b/e2e/rust/tests/local_driver_token_restart.rs index 54e354833d..5223e3a704 100644 --- a/e2e/rust/tests/local_driver_token_restart.rs +++ b/e2e/rust/tests/local_driver_token_restart.rs @@ -3,11 +3,11 @@ #![cfg(feature = "e2e")] -//! Local-driver E2E regression for sandbox supervisor restart from bootstrap -//! JWT material. Docker and Podman supervisors reload their mounted token file -//! after a container restart. VM sandboxes reboot from persisted driver state -//! after the VM driver restarts. Local single-player gateway configs should -//! mint that token with `exp = 0` so reconnect does not depend on token refresh. +//! Local-driver E2E regression for sandbox bootstrap JWT material and terminal +//! main-process semantics. Local single-player gateways mint non-expiring +//! bootstrap tokens. Stopping a Docker or Podman sandbox container is terminal +//! and must not relaunch its canonical process; restarting the VM gateway still +//! exercises driver recovery without deliberately stopping the sandbox. use std::fs; use std::path::PathBuf; @@ -18,6 +18,7 @@ use base64::Engine as _; use openshell_e2e::harness::cli::{wait_for_healthy, wait_for_sandbox_exec_contains}; use openshell_e2e::harness::container::{ContainerEngine, e2e_driver}; use openshell_e2e::harness::gateway::ManagedGateway; +use openshell_e2e::harness::output::strip_ansi; use openshell_e2e::harness::sandbox::SandboxGuard; use prost::Message; use tokio::time::sleep; @@ -266,7 +267,7 @@ fn require_non_expiring_token(token: &str, context: &str) -> Result<(), String> Ok(()) } -async fn restart_container_sandbox( +async fn stop_container_sandbox( engine: &ContainerEngine, driver: LocalDriver, namespace: &str, @@ -277,10 +278,34 @@ async fn restart_container_sandbox( require_non_expiring_token(&token, "local-driver bootstrap JWT")?; run_engine(engine, &["stop".to_string(), container_id.clone()])?; - wait_for_container_running(engine, &container_id, false, Duration::from_secs(60)).await?; + wait_for_container_running(engine, &container_id, false, Duration::from_secs(60)).await +} - run_engine(engine, &["start".to_string(), container_id.clone()])?; - wait_for_container_running(engine, &container_id, true, Duration::from_secs(60)).await +async fn wait_for_sandbox_error(sandbox_name: &str, timeout: Duration) -> Result<(), String> { + let deadline = Instant::now() + timeout; + let mut last_output = String::new(); + while Instant::now() < deadline { + let mut cmd = openshell_e2e::harness::binary::openshell_cmd(); + cmd.args(["sandbox", "get", sandbox_name]) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + let output = cmd + .output() + .await + .map_err(|err| format!("failed to run sandbox get: {err}"))?; + last_output = format!( + "{}{}", + String::from_utf8_lossy(&output.stdout), + String::from_utf8_lossy(&output.stderr) + ); + if output.status.success() && strip_ansi(&last_output).contains("Phase: Error") { + return Ok(()); + } + sleep(Duration::from_millis(250)).await; + } + Err(format!( + "sandbox {sandbox_name} did not enter Error within {timeout:?}:\n{last_output}" + )) } async fn restart_vm_sandbox(gateway: &ManagedGateway, sandbox_name: &str) -> Result<(), String> { @@ -316,11 +341,9 @@ async fn wait_for_driver_reconnect(driver: LocalDriver, sandbox_name: &str) -> R } #[tokio::test] -async fn local_driver_sandbox_restarts_with_non_expiring_bootstrap_jwt() { +async fn local_driver_restart_or_stop_respects_main_process_lifecycle() { let Some(driver) = LocalDriver::from_env() else { - eprintln!( - "Skipping local-driver token restart test: e2e driver is not Docker, Podman, or VM" - ); + eprintln!("Skipping local-driver lifecycle test: e2e driver is not Docker, Podman, or VM"); return; }; let namespace = if driver.is_container() { @@ -329,7 +352,7 @@ async fn local_driver_sandbox_restarts_with_non_expiring_bootstrap_jwt() { .filter(|value| !value.trim().is_empty()) else { eprintln!( - "Skipping local-driver token restart test: OPENSHELL_E2E_SANDBOX_NAMESPACE is unavailable" + "Skipping local-driver lifecycle test: OPENSHELL_E2E_SANDBOX_NAMESPACE is unavailable" ); return; }; @@ -349,7 +372,7 @@ async fn local_driver_sandbox_restarts_with_non_expiring_bootstrap_jwt() { let Some(gateway) = ManagedGateway::from_env().expect("load managed e2e gateway metadata") else { eprintln!( - "Skipping local-driver token restart test: VM e2e gateway is not managed by this test run" + "Skipping local-driver lifecycle test: VM e2e gateway is not managed by this test run" ); return; }; @@ -375,9 +398,12 @@ async fn local_driver_sandbox_restarts_with_non_expiring_bootstrap_jwt() { let namespace = namespace .as_deref() .expect("container namespace should be set"); - restart_container_sandbox(engine, driver, namespace, &sandbox.name) + stop_container_sandbox(engine, driver, namespace, &sandbox.name) + .await + .expect("stop sandbox container"); + wait_for_sandbox_error(&sandbox.name, Duration::from_secs(30)) .await - .expect("restart sandbox container"); + .expect("stopped canonical process should make sandbox terminal"); } LocalDriver::Vm => { let gateway = gateway.as_ref().expect("managed VM gateway should be set"); @@ -387,9 +413,11 @@ async fn local_driver_sandbox_restarts_with_non_expiring_bootstrap_jwt() { } } - wait_for_driver_reconnect(driver, &sandbox.name) - .await - .expect("sandbox supervisor should reconnect after local-driver restart"); + if driver == LocalDriver::Vm { + wait_for_driver_reconnect(driver, &sandbox.name) + .await + .expect("sandbox supervisor should reconnect after VM driver restart"); + } sandbox.cleanup().await; } diff --git a/e2e/rust/tests/provider_auto_create.rs b/e2e/rust/tests/provider_auto_create.rs index 45729776ea..194c7fbf8b 100644 --- a/e2e/rust/tests/provider_auto_create.rs +++ b/e2e/rust/tests/provider_auto_create.rs @@ -89,12 +89,10 @@ async fn auto_created_provider_credential_available_in_sandbox() { let mut cmd = openshell_cmd(); cmd.arg("sandbox") .arg("create") + .arg("--detach") .arg("--provider") .arg("claude-code") .arg("--auto-providers") - .arg("--") - .arg("printenv") - .arg("ANTHROPIC_API_KEY") .env("ANTHROPIC_API_KEY", TEST_API_KEY) .stdout(Stdio::piped()) .stderr(Stdio::piped()); @@ -110,7 +108,26 @@ async fn auto_created_provider_credential_available_in_sandbox() { let clean = strip_ansi(&combined); // Parse sandbox name for cleanup. - let sandbox_name = extract_field(&combined, "Name"); + let sandbox_name = extract_field(&combined, "Created sandbox"); + let exec_output = if let Some(ref name) = sandbox_name { + let mut exec_cmd = openshell_cmd(); + exec_cmd + .args([ + "sandbox", + "exec", + "--name", + name, + "--no-tty", + "--", + "printenv", + "ANTHROPIC_API_KEY", + ]) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + Some(exec_cmd.output().await.expect("failed to run sandbox exec")) + } else { + None + }; // Always clean up, even if assertions fail. if let Some(ref name) = sandbox_name { @@ -125,18 +142,29 @@ async fn auto_created_provider_credential_available_in_sandbox() { output.status.code() ); + let exec_output = exec_output.expect("sandbox name should be present"); + let exec_clean = strip_ansi(&format!( + "{}{}", + String::from_utf8_lossy(&exec_output.stdout), + String::from_utf8_lossy(&exec_output.stderr) + )); + assert!( + exec_output.status.success(), + "sandbox exec should succeed:\n{exec_clean}" + ); + assert!( clean.contains("Created provider claude-code"), "output should confirm provider auto-creation:\n{clean}" ); assert!( - contains_placeholder_for_env_key(&clean, "ANTHROPIC_API_KEY"), - "sandbox should have placeholder ANTHROPIC_API_KEY in its environment:\n{clean}" + contains_placeholder_for_env_key(&exec_clean, "ANTHROPIC_API_KEY"), + "sandbox should have placeholder ANTHROPIC_API_KEY in its environment:\n{exec_clean}" ); assert!( - !clean.contains(TEST_API_KEY), - "sandbox should not expose the raw ANTHROPIC_API_KEY secret:\n{clean}" + !exec_clean.contains(TEST_API_KEY), + "sandbox should not expose the raw ANTHROPIC_API_KEY secret:\n{exec_clean}" ); } diff --git a/e2e/rust/tests/sandbox_labels.rs b/e2e/rust/tests/sandbox_labels.rs index 890b1ad960..4de545d7bb 100644 --- a/e2e/rust/tests/sandbox_labels.rs +++ b/e2e/rust/tests/sandbox_labels.rs @@ -33,15 +33,13 @@ fn extract_sandbox_name(output: &str) -> Option { async fn create_sandbox_with_labels(name: &str, labels: &[(&str, &str)]) -> String { let mut cmd = openshell_cmd(); - cmd.args(["sandbox", "create", "--name", name]); + cmd.args(["sandbox", "create", "--detach", "--name", name]); for (key, value) in labels { cmd.arg("--label").arg(format!("{key}={value}")); } - cmd.args(["--", "echo", "test"]) - .stdout(Stdio::piped()) - .stderr(Stdio::piped()); + cmd.stdout(Stdio::piped()).stderr(Stdio::piped()); let output = cmd.output().await.expect("spawn openshell sandbox create"); let stdout = String::from_utf8_lossy(&output.stdout).to_string(); diff --git a/e2e/rust/tests/sandbox_lifecycle.rs b/e2e/rust/tests/sandbox_lifecycle.rs index 75e34b3b4f..74f15f6313 100644 --- a/e2e/rust/tests/sandbox_lifecycle.rs +++ b/e2e/rust/tests/sandbox_lifecycle.rs @@ -219,7 +219,7 @@ async fn sandbox_can_be_deleted_while_stopped() { } #[tokio::test] -async fn sandbox_create_keeps_sandbox_after_tty_command_by_default() { +async fn canonical_main_exit_transitions_persistent_sandbox_to_error() { let mut cmd = openshell_tty_cmd(&["sandbox", "create", "--", "echo", "OK"]); cmd.stdout(Stdio::piped()).stderr(Stdio::piped()); @@ -229,15 +229,9 @@ async fn sandbox_create_keeps_sandbox_after_tty_command_by_default() { let combined = normalize_output(&format!("{stdout}{stderr}")); assert!( - output.status.success(), - "sandbox create should succeed (exit {:?}):\n{combined}", - output.status.code() + !output.status.success(), + "main-process exit must fail create" ); - assert!( - combined.contains("OK"), - "expected command output in:\n{combined}" - ); - let sandbox_name = extract_sandbox_name(&combined).expect("sandbox name should be present in output"); @@ -249,6 +243,26 @@ async fn sandbox_create_keeps_sandbox_after_tty_command_by_default() { ); } + let mut get_cmd = openshell_cmd(); + get_cmd + .args(["sandbox", "get", &sandbox_name]) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + let get_output = get_cmd.output().await.expect("spawn openshell sandbox get"); + let details = normalize_output(&format!( + "{}{}", + String::from_utf8_lossy(&get_output.stdout), + String::from_utf8_lossy(&get_output.stderr), + )); + assert!( + get_output.status.success(), + "sandbox get failed:\n{details}" + ); + assert!( + details.contains("Phase: Error"), + "expected terminal sandbox phase:\n{details}" + ); + delete_sandbox(&sandbox_name).await; } @@ -263,15 +277,9 @@ async fn sandbox_create_with_no_keep_cleans_up_after_tty_command() { let combined = normalize_output(&format!("{stdout}{stderr}")); assert!( - output.status.success(), - "sandbox create should succeed (exit {:?}):\n{combined}", - output.status.code() - ); - assert!( - combined.contains("OK"), - "expected command output in:\n{combined}" + !output.status.success(), + "main-process exit must fail create" ); - let sandbox_name = extract_sandbox_name(&combined).expect("sandbox name should be present in output"); diff --git a/proto/compute_driver.proto b/proto/compute_driver.proto index 0ce4f61539..66254ea22b 100644 --- a/proto/compute_driver.proto +++ b/proto/compute_driver.proto @@ -72,6 +72,10 @@ message GetCapabilitiesResponse { string driver_version = 2; // Default sandbox image recommended by the driver. string default_image = 3; + // Whether the driver forwards the exact canonical main-process contract. + // Gateways reject creation when this is false so older external drivers + // cannot silently substitute their legacy idle entrypoint. + bool supports_main_process = 6; } message GetGatewayListenerRequirementsRequest {} @@ -142,6 +146,16 @@ message DriverSandboxSpec { // ServiceAccount token bootstrap instead). Never echoed to the public // Sandbox proto. string sandbox_token = 11 [(openshell.options.v1.secret) = true]; + // Exact canonical process specification forwarded to the supervisor. + MainProcessSpec main_process = 12; +} + +// Exact, shell-free specification for the canonical main process. +message MainProcessSpec { + repeated string command = 1; + map environment = 2; + string working_directory = 3; + bool terminal = 4; } message ResourceRequirements { diff --git a/proto/openshell.proto b/proto/openshell.proto index 6d756721f6..7ec9716e18 100644 --- a/proto/openshell.proto +++ b/proto/openshell.proto @@ -772,6 +772,9 @@ message ComputeDriverCapabilities { // Driver-reported implementation version from the startup capability snapshot. string driver_version = 2; + + // Whether the driver can launch the exact canonical main-process contract. + bool supports_main_process = 3; } // Public sandbox resource exposed by the OpenShell API. @@ -817,6 +820,22 @@ message SandboxSpec { // managed fleet-wide. reserved 11; reserved "proposal_approval_mode"; + // Canonical process launched once by the sandbox supervisor. The gateway + // normalizes an omitted value to the portable scratch login shell before + // persisting a newly-created sandbox. + MainProcessSpec main_process = 12; +} + +// Exact, shell-free specification for the sandbox's canonical main process. +message MainProcessSpec { + // Executable followed by its arguments. No shell parsing is performed. + repeated string command = 1; + // Non-secret environment overrides applied only to the main process. + map environment = 2; + // Optional absolute working directory inside the sandbox. + string working_directory = 3; + // Allocate a retained pseudo-terminal for the main process. + bool terminal = 4; } message ResourceRequirements { @@ -880,6 +899,26 @@ message SandboxStatus { SandboxPhase phase = 6; // Currently active policy version (updated when sandbox reports loaded). uint32 current_policy_version = 7; + // Last observed state of the canonical main process. + MainProcessStatus main_process = 8; +} + +// Lifecycle state of the canonical main process. +enum MainProcessState { + MAIN_PROCESS_STATE_UNSPECIFIED = 0; + MAIN_PROCESS_STATE_RUNNING = 1; + MAIN_PROCESS_STATE_EXITED = 2; +} + +// Persisted result for the canonical main-process generation. +message MainProcessStatus { + MainProcessState state = 1; + // Supervisor instance identifier used to reject stale exit reports. + string generation = 2; + optional int32 exit_code = 3; + optional int32 signal = 4; + int64 started_at_ms = 5; + int64 finished_at_ms = 6; } // User-facing sandbox condition derived from driver-native conditions. @@ -2063,6 +2102,7 @@ message SupervisorMessage { SupervisorHeartbeat heartbeat = 2; RelayOpenResult relay_open_result = 3; RelayClose relay_close = 4; + MainProcessExit main_process_exit = 5; } } @@ -2074,6 +2114,7 @@ message GatewayMessage { GatewayHeartbeat heartbeat = 3; RelayOpen relay_open = 4; RelayClose relay_close = 5; + MainProcessExitAck main_process_exit_ack = 6; } } @@ -2083,6 +2124,9 @@ message SupervisorHello { string sandbox_id = 1; // Supervisor instance ID (e.g. boot id or process epoch). string instance_id = 2; + // Short-lived terminal-result sessions authenticate an existing generation + // but must not replace the active relay session or advertise readiness. + bool exit_report_only = 3; } // Gateway accepts the supervisor session. @@ -2105,6 +2149,21 @@ message SupervisorHeartbeat {} // Gateway heartbeat. message GatewayHeartbeat {} +// Terminal result reported before the supervisor shuts down. A missing exit +// code with a present signal represents signal termination. +message MainProcessExit { + string generation = 1; + optional int32 exit_code = 2; + optional int32 signal = 3; + int64 started_at_ms = 4; + int64 finished_at_ms = 5; +} + +// Gateway acknowledgement that the terminal result has been durably handled. +message MainProcessExitAck { + string generation = 1; +} + // Gateway requests the supervisor to open a relay channel. // // On receiving this, the supervisor should initiate a RelayStream RPC to diff --git a/python/openshell/_proto/__init__.py b/python/openshell/_proto/__init__.py index 3ace22421c..41115e87dc 100644 --- a/python/openshell/_proto/__init__.py +++ b/python/openshell/_proto/__init__.py @@ -2,7 +2,13 @@ # Sandbox messages and phase enums moved into openshell.proto. Keep aliases on # datamodel_pb2 so existing Python callers and E2E tests continue to work. -for _name in ("Sandbox", "SandboxSpec", "SandboxTemplate"): +for _name in ( + "MainProcessSpec", + "MainProcessStatus", + "Sandbox", + "SandboxSpec", + "SandboxTemplate", +): if not hasattr(datamodel_pb2, _name): setattr(datamodel_pb2, _name, getattr(openshell_pb2, _name)) diff --git a/python/openshell/sandbox.py b/python/openshell/sandbox.py index a76be8dd13..e2dcc8683f 100644 --- a/python/openshell/sandbox.py +++ b/python/openshell/sandbox.py @@ -126,10 +126,21 @@ def _normalize_bearer( return lambda: token +@dataclass(frozen=True) +class MainProcessStatusRef: + state: int + generation: str + exit_code: int | None + signal: int | None + started_at_ms: int + finished_at_ms: int + + @dataclass(frozen=True) class SandboxStatusRef: phase: int current_policy_version: int + main_process: MainProcessStatusRef | None = None class _ImmutableLabels(dict[str, str]): @@ -1085,6 +1096,11 @@ def _serialize_python_callable( def _sandbox_ref(sandbox: openshell_pb2.Sandbox) -> SandboxRef: status = sandbox.status if sandbox.HasField("status") else None + main = ( + status.main_process + if status is not None and status.HasField("main_process") + else None + ) return SandboxRef( id=sandbox.metadata.id if sandbox.metadata else "", name=sandbox.metadata.name if sandbox.metadata else "", @@ -1092,6 +1108,18 @@ def _sandbox_ref(sandbox: openshell_pb2.Sandbox) -> SandboxRef: status=SandboxStatusRef( phase=status.phase if status else 0, current_policy_version=status.current_policy_version if status else 0, + main_process=( + MainProcessStatusRef( + state=main.state, + generation=main.generation, + exit_code=main.exit_code if main.HasField("exit_code") else None, + signal=main.signal if main.HasField("signal") else None, + started_at_ms=main.started_at_ms, + finished_at_ms=main.finished_at_ms, + ) + if main is not None + else None + ), ), labels=sandbox.metadata.labels if sandbox.metadata else {}, ) diff --git a/python/openshell/sandbox_test.py b/python/openshell/sandbox_test.py index 9ff84341e7..28df327a53 100644 --- a/python/openshell/sandbox_test.py +++ b/python/openshell/sandbox_test.py @@ -1772,6 +1772,25 @@ def test_sandbox_ref_retains_gateway_labels() -> None: assert dict(ref.labels) == {"aiq": "deep-research", "env": "dev"} +def test_sandbox_ref_includes_main_process_result() -> None: + proto = _make_sandbox_proto("sandbox-1", "job-1") + proto.status.main_process.state = openshell_pb2.MAIN_PROCESS_STATE_EXITED + proto.status.main_process.generation = "generation-1" + proto.status.main_process.exit_code = 0 + proto.status.main_process.started_at_ms = 10 + proto.status.main_process.finished_at_ms = 20 + + main = _sandbox_ref(proto).status.main_process + + assert main is not None + assert main.state == openshell_pb2.MAIN_PROCESS_STATE_EXITED + assert main.generation == "generation-1" + assert main.exit_code == 0 + assert main.signal is None + assert main.started_at_ms == 10 + assert main.finished_at_ms == 20 + + def test_returned_labels_are_immutable() -> None: proto = _make_sandbox_proto("sandbox-1", "job-1", {"aiq": "deep-research"}) ref = _sandbox_ref(proto) diff --git a/sdk/go/openshell/v1/internal/converter/copy.go b/sdk/go/openshell/v1/internal/converter/copy.go index e2523a61c3..dc98588fdd 100644 --- a/sdk/go/openshell/v1/internal/converter/copy.go +++ b/sdk/go/openshell/v1/internal/converter/copy.go @@ -26,6 +26,15 @@ func CopyBoolPtr(p *bool) *bool { return &v } +// CopyInt32Ptr returns a copy of an *int32 pointer. +func CopyInt32Ptr(p *int32) *int32 { + if p == nil { + return nil + } + v := *p + return &v +} + // CopyStringSlice returns a copy of a string slice. // Returns nil for nil input. func CopyStringSlice(s []string) []string { diff --git a/sdk/go/openshell/v1/internal/converter/coverage_test.go b/sdk/go/openshell/v1/internal/converter/coverage_test.go index 33edebf64f..0f6c3d5c5f 100644 --- a/sdk/go/openshell/v1/internal/converter/coverage_test.go +++ b/sdk/go/openshell/v1/internal/converter/coverage_test.go @@ -29,6 +29,7 @@ func TestConverterCoversAllProtoFields_SandboxSpec(t *testing.T) { "policy": true, "providers": true, "resource_requirements": true, + "main_process": true, } assertAllFieldsCovered(t, (&pb.SandboxSpec{}).ProtoReflect().Descriptor(), handled, nil) @@ -59,6 +60,7 @@ func TestConverterCoversAllProtoFields_SandboxStatus(t *testing.T) { "phase": true, "conditions": true, "current_policy_version": true, + "main_process": true, } assertAllFieldsCovered(t, (&pb.SandboxStatus{}).ProtoReflect().Descriptor(), handled, nil) diff --git a/sdk/go/openshell/v1/internal/converter/sandbox.go b/sdk/go/openshell/v1/internal/converter/sandbox.go index f44210fd2e..37d6603bb8 100644 --- a/sdk/go/openshell/v1/internal/converter/sandbox.go +++ b/sdk/go/openshell/v1/internal/converter/sandbox.go @@ -76,6 +76,14 @@ func sandboxSpecFromProto(spec *pb.SandboxSpec) types.SandboxSpec { result.GPUCount = gpu.Count } } + if main := spec.GetMainProcess(); main != nil { + result.MainProcess = &types.MainProcessSpec{ + Command: CopyStringSlice(main.GetCommand()), + Environment: CopyStringMap(main.GetEnvironment()), + WorkingDirectory: main.GetWorkingDirectory(), + Terminal: main.GetTerminal(), + } + } return result } @@ -99,6 +107,16 @@ func sandboxStatusFromProto(status *pb.SandboxStatus) types.SandboxStatus { LastTransitionTime: c.GetLastTransitionTime(), }) } + if main := status.GetMainProcess(); main != nil { + result.MainProcess = &types.MainProcessStatus{ + State: int32(main.GetState()), + Generation: main.GetGeneration(), + ExitCode: CopyInt32Ptr(main.ExitCode), + Signal: CopyInt32Ptr(main.Signal), + StartedAt: TimeFromMillis(main.GetStartedAtMs()), + FinishedAt: TimeFromMillis(main.GetFinishedAtMs()), + } + } return result } @@ -220,6 +238,15 @@ func SandboxSpecToProto(spec *types.SandboxSpec) *pb.SandboxSpec { } } + if spec.MainProcess != nil { + result.MainProcess = &pb.MainProcessSpec{ + Command: CopyStringSlice(spec.MainProcess.Command), + Environment: CopyStringMap(spec.MainProcess.Environment), + WorkingDirectory: spec.MainProcess.WorkingDirectory, + Terminal: spec.MainProcess.Terminal, + } + } + return result } diff --git a/sdk/go/openshell/v1/internal/converter/sandbox_test.go b/sdk/go/openshell/v1/internal/converter/sandbox_test.go index b0b721eda1..7013fee585 100644 --- a/sdk/go/openshell/v1/internal/converter/sandbox_test.go +++ b/sdk/go/openshell/v1/internal/converter/sandbox_test.go @@ -19,6 +19,7 @@ import ( func TestSandboxFromProto(t *testing.T) { userNS := true gpuCount := uint32(2) + exitCode := int32(0) proto := &pb.Sandbox{ Metadata: &dm.ObjectMeta{ Id: "sb-1", @@ -56,6 +57,12 @@ func TestSandboxFromProto(t *testing.T) { Count: &gpuCount, }, }, + MainProcess: &pb.MainProcessSpec{ + Command: []string{"/opt/agent", "--serve"}, + Environment: map[string]string{"MODE": "worker"}, + WorkingDirectory: "/sandbox/app", + Terminal: false, + }, }, Status: &pb.SandboxStatus{ SandboxName: "sb-compute-1", @@ -64,6 +71,13 @@ func TestSandboxFromProto(t *testing.T) { SandboxFd: "fd-sandbox", Phase: pb.SandboxPhase_SANDBOX_PHASE_READY, CurrentPolicyVersion: 7, + MainProcess: &pb.MainProcessStatus{ + State: pb.MainProcessState_MAIN_PROCESS_STATE_EXITED, + Generation: "generation-1", + ExitCode: &exitCode, + StartedAtMs: 1700000001000, + FinishedAtMs: 1700000002000, + }, Conditions: []*pb.SandboxCondition{ { Type: "Ready", @@ -95,6 +109,11 @@ func TestSandboxFromProto(t *testing.T) { assert.Equal(t, []string{"claude", "github"}, s.Spec.Providers) require.NotNil(t, s.Spec.GPUCount) assert.Equal(t, uint32(2), *s.Spec.GPUCount) + require.NotNil(t, s.Spec.MainProcess) + assert.Equal(t, []string{"/opt/agent", "--serve"}, s.Spec.MainProcess.Command) + assert.Equal(t, map[string]string{"MODE": "worker"}, s.Spec.MainProcess.Environment) + assert.Equal(t, "/sandbox/app", s.Spec.MainProcess.WorkingDirectory) + assert.False(t, s.Spec.MainProcess.Terminal) // Template require.NotNil(t, s.Spec.Template) @@ -125,6 +144,14 @@ func TestSandboxFromProto(t *testing.T) { assert.Equal(t, "AllGood", s.Status.Conditions[0].Reason) assert.Equal(t, "Sandbox is ready", s.Status.Conditions[0].Message) assert.Equal(t, "2024-01-01T00:00:00Z", s.Status.Conditions[0].LastTransitionTime) + require.NotNil(t, s.Status.MainProcess) + assert.Equal(t, int32(pb.MainProcessState_MAIN_PROCESS_STATE_EXITED), s.Status.MainProcess.State) + assert.Equal(t, "generation-1", s.Status.MainProcess.Generation) + require.NotNil(t, s.Status.MainProcess.ExitCode) + assert.Equal(t, int32(0), *s.Status.MainProcess.ExitCode) + assert.Nil(t, s.Status.MainProcess.Signal) + assert.Equal(t, time.UnixMilli(1700000001000).UTC(), s.Status.MainProcess.StartedAt) + assert.Equal(t, time.UnixMilli(1700000002000).UTC(), s.Status.MainProcess.FinishedAt) } func TestSandboxFromProto_TemplateResourcesDeepCopy(t *testing.T) { @@ -243,6 +270,12 @@ func TestSandboxToProto(t *testing.T) { }, Providers: []string{"prov-a"}, GPUCount: &gpuCount, + MainProcess: &v1.MainProcessSpec{ + Command: []string{"/opt/agent", "--serve"}, + Environment: map[string]string{"MODE": "worker"}, + WorkingDirectory: "/sandbox/app", + Terminal: false, + }, }, } @@ -263,6 +296,11 @@ func TestSandboxToProto(t *testing.T) { assert.Equal(t, "info", p.Spec.LogLevel) assert.Equal(t, map[string]string{"KEY": "val"}, p.Spec.Environment) assert.Equal(t, []string{"prov-a"}, p.Spec.Providers) + require.NotNil(t, p.Spec.MainProcess) + assert.Equal(t, []string{"/opt/agent", "--serve"}, p.Spec.MainProcess.Command) + assert.Equal(t, map[string]string{"MODE": "worker"}, p.Spec.MainProcess.Environment) + assert.Equal(t, "/sandbox/app", p.Spec.MainProcess.WorkingDirectory) + assert.False(t, p.Spec.MainProcess.Terminal) require.NotNil(t, p.Spec.ResourceRequirements) require.NotNil(t, p.Spec.ResourceRequirements.Gpu) diff --git a/sdk/go/openshell/v1/types/sandbox.go b/sdk/go/openshell/v1/types/sandbox.go index 5851ff48d7..4c4e88b850 100644 --- a/sdk/go/openshell/v1/types/sandbox.go +++ b/sdk/go/openshell/v1/types/sandbox.go @@ -27,7 +27,16 @@ type SandboxSpec struct { Providers []string GPUCount *uint32 // Policy is the security policy for the sandbox. Nil means no policy specified. - Policy *SandboxPolicy + Policy *SandboxPolicy + MainProcess *MainProcessSpec +} + +// MainProcessSpec is the exact canonical process launched once per sandbox. +type MainProcessSpec struct { + Command []string + Environment map[string]string + WorkingDirectory string + Terminal bool } // SandboxTemplate defines the container template for a sandbox. @@ -52,6 +61,17 @@ type SandboxStatus struct { Phase SandboxPhase Conditions []SandboxCondition CurrentPolicyVersion uint32 + MainProcess *MainProcessStatus +} + +// MainProcessStatus records the active or terminal canonical-process generation. +type MainProcessStatus struct { + State int32 + Generation string + ExitCode *int32 + Signal *int32 + StartedAt time.Time + FinishedAt time.Time } // SandboxCondition describes an observed condition of a sandbox. diff --git a/sdk/go/proto/openshellv1/openshell.pb.go b/sdk/go/proto/openshellv1/openshell.pb.go index acf7d6554e..98fe2ccd3c 100644 --- a/sdk/go/proto/openshellv1/openshell.pb.go +++ b/sdk/go/proto/openshellv1/openshell.pb.go @@ -28,6 +28,56 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) +// Lifecycle state of the canonical main process. +type MainProcessState int32 + +const ( + MainProcessState_MAIN_PROCESS_STATE_UNSPECIFIED MainProcessState = 0 + MainProcessState_MAIN_PROCESS_STATE_RUNNING MainProcessState = 1 + MainProcessState_MAIN_PROCESS_STATE_EXITED MainProcessState = 2 +) + +// Enum value maps for MainProcessState. +var ( + MainProcessState_name = map[int32]string{ + 0: "MAIN_PROCESS_STATE_UNSPECIFIED", + 1: "MAIN_PROCESS_STATE_RUNNING", + 2: "MAIN_PROCESS_STATE_EXITED", + } + MainProcessState_value = map[string]int32{ + "MAIN_PROCESS_STATE_UNSPECIFIED": 0, + "MAIN_PROCESS_STATE_RUNNING": 1, + "MAIN_PROCESS_STATE_EXITED": 2, + } +) + +func (x MainProcessState) Enum() *MainProcessState { + p := new(MainProcessState) + *p = x + return p +} + +func (x MainProcessState) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (MainProcessState) Descriptor() protoreflect.EnumDescriptor { + return file_openshell_proto_enumTypes[0].Descriptor() +} + +func (MainProcessState) Type() protoreflect.EnumType { + return &file_openshell_proto_enumTypes[0] +} + +func (x MainProcessState) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use MainProcessState.Descriptor instead. +func (MainProcessState) EnumDescriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{0} +} + // High-level sandbox lifecycle phase derived by the gateway. // // Clients should rely on this normalized lifecycle summary for readiness and @@ -83,11 +133,11 @@ func (x SandboxPhase) String() string { } func (SandboxPhase) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[0].Descriptor() + return file_openshell_proto_enumTypes[1].Descriptor() } func (SandboxPhase) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[0] + return &file_openshell_proto_enumTypes[1] } func (x SandboxPhase) Number() protoreflect.EnumNumber { @@ -96,7 +146,7 @@ func (x SandboxPhase) Number() protoreflect.EnumNumber { // Deprecated: Use SandboxPhase.Descriptor instead. func (SandboxPhase) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{0} + return file_openshell_proto_rawDescGZIP(), []int{1} } type ProviderCredentialRefreshStrategy int32 @@ -144,11 +194,11 @@ func (x ProviderCredentialRefreshStrategy) String() string { } func (ProviderCredentialRefreshStrategy) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[1].Descriptor() + return file_openshell_proto_enumTypes[2].Descriptor() } func (ProviderCredentialRefreshStrategy) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[1] + return &file_openshell_proto_enumTypes[2] } func (x ProviderCredentialRefreshStrategy) Number() protoreflect.EnumNumber { @@ -157,7 +207,7 @@ func (x ProviderCredentialRefreshStrategy) Number() protoreflect.EnumNumber { // Deprecated: Use ProviderCredentialRefreshStrategy.Descriptor instead. func (ProviderCredentialRefreshStrategy) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{1} + return file_openshell_proto_rawDescGZIP(), []int{2} } // Stable provider profile categories used by clients for grouping and filtering. @@ -209,11 +259,11 @@ func (x ProviderProfileCategory) String() string { } func (ProviderProfileCategory) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[2].Descriptor() + return file_openshell_proto_enumTypes[3].Descriptor() } func (ProviderProfileCategory) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[2] + return &file_openshell_proto_enumTypes[3] } func (x ProviderProfileCategory) Number() protoreflect.EnumNumber { @@ -222,7 +272,7 @@ func (x ProviderProfileCategory) Number() protoreflect.EnumNumber { // Deprecated: Use ProviderProfileCategory.Descriptor instead. func (ProviderProfileCategory) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{2} + return file_openshell_proto_rawDescGZIP(), []int{3} } // Policy load status. @@ -269,11 +319,11 @@ func (x PolicyStatus) String() string { } func (PolicyStatus) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[3].Descriptor() + return file_openshell_proto_enumTypes[4].Descriptor() } func (PolicyStatus) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[3] + return &file_openshell_proto_enumTypes[4] } func (x PolicyStatus) Number() protoreflect.EnumNumber { @@ -282,7 +332,7 @@ func (x PolicyStatus) Number() protoreflect.EnumNumber { // Deprecated: Use PolicyStatus.Descriptor instead. func (PolicyStatus) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{3} + return file_openshell_proto_rawDescGZIP(), []int{4} } // Service status enum. @@ -322,11 +372,11 @@ func (x ServiceStatus) String() string { } func (ServiceStatus) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[4].Descriptor() + return file_openshell_proto_enumTypes[5].Descriptor() } func (ServiceStatus) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[4] + return &file_openshell_proto_enumTypes[5] } func (x ServiceStatus) Number() protoreflect.EnumNumber { @@ -335,7 +385,7 @@ func (x ServiceStatus) Number() protoreflect.EnumNumber { // Deprecated: Use ServiceStatus.Descriptor instead. func (ServiceStatus) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{4} + return file_openshell_proto_rawDescGZIP(), []int{5} } // Workspace-scoped role for members. @@ -372,11 +422,11 @@ func (x WorkspaceRole) String() string { } func (WorkspaceRole) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[5].Descriptor() + return file_openshell_proto_enumTypes[6].Descriptor() } func (WorkspaceRole) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[5] + return &file_openshell_proto_enumTypes[6] } func (x WorkspaceRole) Number() protoreflect.EnumNumber { @@ -385,7 +435,7 @@ func (x WorkspaceRole) Number() protoreflect.EnumNumber { // Deprecated: Use WorkspaceRole.Descriptor instead. func (WorkspaceRole) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{5} + return file_openshell_proto_rawDescGZIP(), []int{6} } // IssueSandboxToken request. Empty body; identity is established by the @@ -978,8 +1028,10 @@ type ComputeDriverCapabilities struct { DriverName string `protobuf:"bytes,1,opt,name=driver_name,json=driverName,proto3" json:"driver_name,omitempty"` // Driver-reported implementation version from the startup capability snapshot. DriverVersion string `protobuf:"bytes,2,opt,name=driver_version,json=driverVersion,proto3" json:"driver_version,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + // Whether the driver can launch the exact canonical main-process contract. + SupportsMainProcess bool `protobuf:"varint,3,opt,name=supports_main_process,json=supportsMainProcess,proto3" json:"supports_main_process,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *ComputeDriverCapabilities) Reset() { @@ -1026,6 +1078,13 @@ func (x *ComputeDriverCapabilities) GetDriverVersion() string { return "" } +func (x *ComputeDriverCapabilities) GetSupportsMainProcess() bool { + if x != nil { + return x.SupportsMainProcess + } + return false +} + // Public sandbox resource exposed by the OpenShell API. // // This is the canonical gateway-owned view of a sandbox. It merges user intent @@ -1113,8 +1172,12 @@ type SandboxSpec struct { // Portable resource requirements used by the gateway for driver selection // and by drivers for provisioning. ResourceRequirements *ResourceRequirements `protobuf:"bytes,9,opt,name=resource_requirements,json=resourceRequirements,proto3" json:"resource_requirements,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + // Canonical process launched once by the sandbox supervisor. The gateway + // normalizes an omitted value to the portable scratch login shell before + // persisting a newly-created sandbox. + MainProcess *MainProcessSpec `protobuf:"bytes,12,opt,name=main_process,json=mainProcess,proto3" json:"main_process,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *SandboxSpec) Reset() { @@ -1189,6 +1252,86 @@ func (x *SandboxSpec) GetResourceRequirements() *ResourceRequirements { return nil } +func (x *SandboxSpec) GetMainProcess() *MainProcessSpec { + if x != nil { + return x.MainProcess + } + return nil +} + +// Exact, shell-free specification for the sandbox's canonical main process. +type MainProcessSpec struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Executable followed by its arguments. No shell parsing is performed. + Command []string `protobuf:"bytes,1,rep,name=command,proto3" json:"command,omitempty"` + // Non-secret environment overrides applied only to the main process. + Environment map[string]string `protobuf:"bytes,2,rep,name=environment,proto3" json:"environment,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + // Optional absolute working directory inside the sandbox. + WorkingDirectory string `protobuf:"bytes,3,opt,name=working_directory,json=workingDirectory,proto3" json:"working_directory,omitempty"` + // Allocate a retained pseudo-terminal for the main process. + Terminal bool `protobuf:"varint,4,opt,name=terminal,proto3" json:"terminal,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *MainProcessSpec) Reset() { + *x = MainProcessSpec{} + mi := &file_openshell_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *MainProcessSpec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MainProcessSpec) ProtoMessage() {} + +func (x *MainProcessSpec) 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 MainProcessSpec.ProtoReflect.Descriptor instead. +func (*MainProcessSpec) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{14} +} + +func (x *MainProcessSpec) GetCommand() []string { + if x != nil { + return x.Command + } + return nil +} + +func (x *MainProcessSpec) GetEnvironment() map[string]string { + if x != nil { + return x.Environment + } + return nil +} + +func (x *MainProcessSpec) GetWorkingDirectory() string { + if x != nil { + return x.WorkingDirectory + } + return "" +} + +func (x *MainProcessSpec) GetTerminal() bool { + if x != nil { + return x.Terminal + } + return false +} + type ResourceRequirements struct { state protoimpl.MessageState `protogen:"open.v1"` // GPU requirements for the sandbox. Presence indicates a GPU request. @@ -1199,7 +1342,7 @@ type ResourceRequirements struct { func (x *ResourceRequirements) Reset() { *x = ResourceRequirements{} - mi := &file_openshell_proto_msgTypes[14] + mi := &file_openshell_proto_msgTypes[15] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1211,7 +1354,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[15] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1224,7 +1367,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{15} } func (x *ResourceRequirements) GetGpu() *GpuResourceRequirements { @@ -1246,7 +1389,7 @@ type GpuResourceRequirements struct { func (x *GpuResourceRequirements) Reset() { *x = GpuResourceRequirements{} - mi := &file_openshell_proto_msgTypes[15] + mi := &file_openshell_proto_msgTypes[16] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1258,7 +1401,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[16] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1271,7 +1414,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{16} } func (x *GpuResourceRequirements) GetCount() uint32 { @@ -1315,7 +1458,7 @@ type SandboxTemplate struct { func (x *SandboxTemplate) Reset() { *x = SandboxTemplate{} - mi := &file_openshell_proto_msgTypes[16] + mi := &file_openshell_proto_msgTypes[17] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1327,7 +1470,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[17] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1340,7 +1483,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{17} } func (x *SandboxTemplate) GetImage() string { @@ -1425,13 +1568,15 @@ type SandboxStatus struct { Phase SandboxPhase `protobuf:"varint,6,opt,name=phase,proto3,enum=openshell.v1.SandboxPhase" json:"phase,omitempty"` // Currently active policy version (updated when sandbox reports loaded). CurrentPolicyVersion uint32 `protobuf:"varint,7,opt,name=current_policy_version,json=currentPolicyVersion,proto3" json:"current_policy_version,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + // Last observed state of the canonical main process. + MainProcess *MainProcessStatus `protobuf:"bytes,8,opt,name=main_process,json=mainProcess,proto3" json:"main_process,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *SandboxStatus) Reset() { *x = SandboxStatus{} - mi := &file_openshell_proto_msgTypes[17] + mi := &file_openshell_proto_msgTypes[18] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1443,7 +1588,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[18] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1456,7 +1601,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{18} } func (x *SandboxStatus) GetSandboxName() string { @@ -1508,6 +1653,99 @@ func (x *SandboxStatus) GetCurrentPolicyVersion() uint32 { return 0 } +func (x *SandboxStatus) GetMainProcess() *MainProcessStatus { + if x != nil { + return x.MainProcess + } + return nil +} + +// Persisted result for the canonical main-process generation. +type MainProcessStatus struct { + state protoimpl.MessageState `protogen:"open.v1"` + State MainProcessState `protobuf:"varint,1,opt,name=state,proto3,enum=openshell.v1.MainProcessState" json:"state,omitempty"` + // Supervisor instance identifier used to reject stale exit reports. + Generation string `protobuf:"bytes,2,opt,name=generation,proto3" json:"generation,omitempty"` + ExitCode *int32 `protobuf:"varint,3,opt,name=exit_code,json=exitCode,proto3,oneof" json:"exit_code,omitempty"` + Signal *int32 `protobuf:"varint,4,opt,name=signal,proto3,oneof" json:"signal,omitempty"` + StartedAtMs int64 `protobuf:"varint,5,opt,name=started_at_ms,json=startedAtMs,proto3" json:"started_at_ms,omitempty"` + FinishedAtMs int64 `protobuf:"varint,6,opt,name=finished_at_ms,json=finishedAtMs,proto3" json:"finished_at_ms,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *MainProcessStatus) Reset() { + *x = MainProcessStatus{} + mi := &file_openshell_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *MainProcessStatus) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MainProcessStatus) ProtoMessage() {} + +func (x *MainProcessStatus) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[19] + 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 MainProcessStatus.ProtoReflect.Descriptor instead. +func (*MainProcessStatus) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{19} +} + +func (x *MainProcessStatus) GetState() MainProcessState { + if x != nil { + return x.State + } + return MainProcessState_MAIN_PROCESS_STATE_UNSPECIFIED +} + +func (x *MainProcessStatus) GetGeneration() string { + if x != nil { + return x.Generation + } + return "" +} + +func (x *MainProcessStatus) GetExitCode() int32 { + if x != nil && x.ExitCode != nil { + return *x.ExitCode + } + return 0 +} + +func (x *MainProcessStatus) GetSignal() int32 { + if x != nil && x.Signal != nil { + return *x.Signal + } + return 0 +} + +func (x *MainProcessStatus) GetStartedAtMs() int64 { + if x != nil { + return x.StartedAtMs + } + return 0 +} + +func (x *MainProcessStatus) GetFinishedAtMs() int64 { + if x != nil { + return x.FinishedAtMs + } + return 0 +} + // User-facing sandbox condition derived from driver-native conditions. type SandboxCondition struct { state protoimpl.MessageState `protogen:"open.v1"` @@ -1527,7 +1765,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) } @@ -1539,7 +1777,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 { @@ -1552,7 +1790,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 { @@ -1611,7 +1849,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) } @@ -1623,7 +1861,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 { @@ -1636,7 +1874,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 { @@ -1699,7 +1937,7 @@ type CreateSandboxRequest struct { 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) } @@ -1711,7 +1949,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 { @@ -1724,7 +1962,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 { @@ -1775,7 +2013,7 @@ type GetSandboxRequest struct { func (x *GetSandboxRequest) Reset() { *x = GetSandboxRequest{} - mi := &file_openshell_proto_msgTypes[21] + mi := &file_openshell_proto_msgTypes[23] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1787,7 +2025,7 @@ func (x *GetSandboxRequest) String() string { func (*GetSandboxRequest) ProtoMessage() {} func (x *GetSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[21] + mi := &file_openshell_proto_msgTypes[23] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1800,7 +2038,7 @@ func (x *GetSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxRequest.ProtoReflect.Descriptor instead. func (*GetSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{21} + return file_openshell_proto_rawDescGZIP(), []int{23} } func (x *GetSandboxRequest) GetName() string { @@ -1834,7 +2072,7 @@ type ListSandboxesRequest struct { func (x *ListSandboxesRequest) Reset() { *x = ListSandboxesRequest{} - mi := &file_openshell_proto_msgTypes[22] + mi := &file_openshell_proto_msgTypes[24] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1846,7 +2084,7 @@ func (x *ListSandboxesRequest) String() string { func (*ListSandboxesRequest) ProtoMessage() {} func (x *ListSandboxesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[22] + mi := &file_openshell_proto_msgTypes[24] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1859,7 +2097,7 @@ func (x *ListSandboxesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxesRequest.ProtoReflect.Descriptor instead. func (*ListSandboxesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{22} + return file_openshell_proto_rawDescGZIP(), []int{24} } func (x *ListSandboxesRequest) GetLimit() uint32 { @@ -1910,7 +2148,7 @@ type ListSandboxProvidersRequest struct { func (x *ListSandboxProvidersRequest) Reset() { *x = ListSandboxProvidersRequest{} - mi := &file_openshell_proto_msgTypes[23] + mi := &file_openshell_proto_msgTypes[25] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1922,7 +2160,7 @@ func (x *ListSandboxProvidersRequest) String() string { func (*ListSandboxProvidersRequest) ProtoMessage() {} func (x *ListSandboxProvidersRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[23] + mi := &file_openshell_proto_msgTypes[25] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1935,7 +2173,7 @@ func (x *ListSandboxProvidersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxProvidersRequest.ProtoReflect.Descriptor instead. func (*ListSandboxProvidersRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{23} + return file_openshell_proto_rawDescGZIP(), []int{25} } func (x *ListSandboxProvidersRequest) GetSandboxName() string { @@ -1972,7 +2210,7 @@ type AttachSandboxProviderRequest struct { func (x *AttachSandboxProviderRequest) Reset() { *x = AttachSandboxProviderRequest{} - mi := &file_openshell_proto_msgTypes[24] + mi := &file_openshell_proto_msgTypes[26] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1984,7 +2222,7 @@ func (x *AttachSandboxProviderRequest) String() string { func (*AttachSandboxProviderRequest) ProtoMessage() {} func (x *AttachSandboxProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[24] + mi := &file_openshell_proto_msgTypes[26] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1997,7 +2235,7 @@ func (x *AttachSandboxProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use AttachSandboxProviderRequest.ProtoReflect.Descriptor instead. func (*AttachSandboxProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{24} + return file_openshell_proto_rawDescGZIP(), []int{26} } func (x *AttachSandboxProviderRequest) GetSandboxName() string { @@ -2048,7 +2286,7 @@ type DetachSandboxProviderRequest struct { func (x *DetachSandboxProviderRequest) Reset() { *x = DetachSandboxProviderRequest{} - mi := &file_openshell_proto_msgTypes[25] + mi := &file_openshell_proto_msgTypes[27] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2060,7 +2298,7 @@ func (x *DetachSandboxProviderRequest) String() string { func (*DetachSandboxProviderRequest) ProtoMessage() {} func (x *DetachSandboxProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[25] + mi := &file_openshell_proto_msgTypes[27] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2073,7 +2311,7 @@ func (x *DetachSandboxProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DetachSandboxProviderRequest.ProtoReflect.Descriptor instead. func (*DetachSandboxProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{25} + return file_openshell_proto_rawDescGZIP(), []int{27} } func (x *DetachSandboxProviderRequest) GetSandboxName() string { @@ -2117,7 +2355,7 @@ type DeleteSandboxRequest struct { func (x *DeleteSandboxRequest) Reset() { *x = DeleteSandboxRequest{} - mi := &file_openshell_proto_msgTypes[26] + mi := &file_openshell_proto_msgTypes[28] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2129,7 +2367,7 @@ func (x *DeleteSandboxRequest) String() string { func (*DeleteSandboxRequest) ProtoMessage() {} func (x *DeleteSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[26] + mi := &file_openshell_proto_msgTypes[28] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2142,7 +2380,7 @@ func (x *DeleteSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteSandboxRequest.ProtoReflect.Descriptor instead. func (*DeleteSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{26} + return file_openshell_proto_rawDescGZIP(), []int{28} } func (x *DeleteSandboxRequest) GetName() string { @@ -2172,7 +2410,7 @@ type StopSandboxRequest struct { func (x *StopSandboxRequest) Reset() { *x = StopSandboxRequest{} - mi := &file_openshell_proto_msgTypes[27] + mi := &file_openshell_proto_msgTypes[29] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2184,7 +2422,7 @@ func (x *StopSandboxRequest) String() string { func (*StopSandboxRequest) ProtoMessage() {} func (x *StopSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[27] + mi := &file_openshell_proto_msgTypes[29] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2197,7 +2435,7 @@ func (x *StopSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use StopSandboxRequest.ProtoReflect.Descriptor instead. func (*StopSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{27} + return file_openshell_proto_rawDescGZIP(), []int{29} } func (x *StopSandboxRequest) GetName() string { @@ -2227,7 +2465,7 @@ type StartSandboxRequest struct { func (x *StartSandboxRequest) Reset() { *x = StartSandboxRequest{} - mi := &file_openshell_proto_msgTypes[28] + mi := &file_openshell_proto_msgTypes[30] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2239,7 +2477,7 @@ func (x *StartSandboxRequest) String() string { func (*StartSandboxRequest) ProtoMessage() {} func (x *StartSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[28] + mi := &file_openshell_proto_msgTypes[30] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2252,7 +2490,7 @@ func (x *StartSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use StartSandboxRequest.ProtoReflect.Descriptor instead. func (*StartSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{28} + return file_openshell_proto_rawDescGZIP(), []int{30} } func (x *StartSandboxRequest) GetName() string { @@ -2279,7 +2517,7 @@ type SandboxResponse struct { func (x *SandboxResponse) Reset() { *x = SandboxResponse{} - mi := &file_openshell_proto_msgTypes[29] + mi := &file_openshell_proto_msgTypes[31] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2291,7 +2529,7 @@ func (x *SandboxResponse) String() string { func (*SandboxResponse) ProtoMessage() {} func (x *SandboxResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[29] + mi := &file_openshell_proto_msgTypes[31] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2304,7 +2542,7 @@ func (x *SandboxResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxResponse.ProtoReflect.Descriptor instead. func (*SandboxResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{29} + return file_openshell_proto_rawDescGZIP(), []int{31} } func (x *SandboxResponse) GetSandbox() *Sandbox { @@ -2324,7 +2562,7 @@ type ListSandboxesResponse struct { func (x *ListSandboxesResponse) Reset() { *x = ListSandboxesResponse{} - mi := &file_openshell_proto_msgTypes[30] + mi := &file_openshell_proto_msgTypes[32] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2336,7 +2574,7 @@ func (x *ListSandboxesResponse) String() string { func (*ListSandboxesResponse) ProtoMessage() {} func (x *ListSandboxesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[30] + mi := &file_openshell_proto_msgTypes[32] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2349,7 +2587,7 @@ func (x *ListSandboxesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxesResponse.ProtoReflect.Descriptor instead. func (*ListSandboxesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{30} + return file_openshell_proto_rawDescGZIP(), []int{32} } func (x *ListSandboxesResponse) GetSandboxes() []*Sandbox { @@ -2369,7 +2607,7 @@ type ListSandboxProvidersResponse struct { func (x *ListSandboxProvidersResponse) Reset() { *x = ListSandboxProvidersResponse{} - mi := &file_openshell_proto_msgTypes[31] + mi := &file_openshell_proto_msgTypes[33] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2381,7 +2619,7 @@ func (x *ListSandboxProvidersResponse) String() string { func (*ListSandboxProvidersResponse) ProtoMessage() {} func (x *ListSandboxProvidersResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[31] + mi := &file_openshell_proto_msgTypes[33] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2394,7 +2632,7 @@ func (x *ListSandboxProvidersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxProvidersResponse.ProtoReflect.Descriptor instead. func (*ListSandboxProvidersResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{31} + return file_openshell_proto_rawDescGZIP(), []int{33} } func (x *ListSandboxProvidersResponse) GetProviders() []*datamodelv1.Provider { @@ -2416,7 +2654,7 @@ type AttachSandboxProviderResponse struct { func (x *AttachSandboxProviderResponse) Reset() { *x = AttachSandboxProviderResponse{} - mi := &file_openshell_proto_msgTypes[32] + mi := &file_openshell_proto_msgTypes[34] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2428,7 +2666,7 @@ func (x *AttachSandboxProviderResponse) String() string { func (*AttachSandboxProviderResponse) ProtoMessage() {} func (x *AttachSandboxProviderResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[32] + mi := &file_openshell_proto_msgTypes[34] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2441,7 +2679,7 @@ func (x *AttachSandboxProviderResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use AttachSandboxProviderResponse.ProtoReflect.Descriptor instead. func (*AttachSandboxProviderResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{32} + return file_openshell_proto_rawDescGZIP(), []int{34} } func (x *AttachSandboxProviderResponse) GetSandbox() *Sandbox { @@ -2470,7 +2708,7 @@ type DetachSandboxProviderResponse struct { func (x *DetachSandboxProviderResponse) Reset() { *x = DetachSandboxProviderResponse{} - mi := &file_openshell_proto_msgTypes[33] + mi := &file_openshell_proto_msgTypes[35] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2482,7 +2720,7 @@ func (x *DetachSandboxProviderResponse) String() string { func (*DetachSandboxProviderResponse) ProtoMessage() {} func (x *DetachSandboxProviderResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[33] + mi := &file_openshell_proto_msgTypes[35] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2495,7 +2733,7 @@ func (x *DetachSandboxProviderResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DetachSandboxProviderResponse.ProtoReflect.Descriptor instead. func (*DetachSandboxProviderResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{33} + return file_openshell_proto_rawDescGZIP(), []int{35} } func (x *DetachSandboxProviderResponse) GetSandbox() *Sandbox { @@ -2522,7 +2760,7 @@ type DeleteSandboxResponse struct { func (x *DeleteSandboxResponse) Reset() { *x = DeleteSandboxResponse{} - mi := &file_openshell_proto_msgTypes[34] + mi := &file_openshell_proto_msgTypes[36] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2534,7 +2772,7 @@ func (x *DeleteSandboxResponse) String() string { func (*DeleteSandboxResponse) ProtoMessage() {} func (x *DeleteSandboxResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[34] + mi := &file_openshell_proto_msgTypes[36] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2547,7 +2785,7 @@ func (x *DeleteSandboxResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteSandboxResponse.ProtoReflect.Descriptor instead. func (*DeleteSandboxResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{34} + return file_openshell_proto_rawDescGZIP(), []int{36} } func (x *DeleteSandboxResponse) GetDeleted() bool { @@ -2568,7 +2806,7 @@ type CreateSshSessionRequest struct { func (x *CreateSshSessionRequest) Reset() { *x = CreateSshSessionRequest{} - mi := &file_openshell_proto_msgTypes[35] + mi := &file_openshell_proto_msgTypes[37] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2580,7 +2818,7 @@ func (x *CreateSshSessionRequest) String() string { func (*CreateSshSessionRequest) ProtoMessage() {} func (x *CreateSshSessionRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[35] + mi := &file_openshell_proto_msgTypes[37] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2593,7 +2831,7 @@ func (x *CreateSshSessionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateSshSessionRequest.ProtoReflect.Descriptor instead. func (*CreateSshSessionRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{35} + return file_openshell_proto_rawDescGZIP(), []int{37} } func (x *CreateSshSessionRequest) GetSandboxId() string { @@ -2636,7 +2874,7 @@ type CreateSshSessionResponse struct { func (x *CreateSshSessionResponse) Reset() { *x = CreateSshSessionResponse{} - mi := &file_openshell_proto_msgTypes[36] + mi := &file_openshell_proto_msgTypes[38] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2648,7 +2886,7 @@ func (x *CreateSshSessionResponse) String() string { func (*CreateSshSessionResponse) ProtoMessage() {} func (x *CreateSshSessionResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[36] + mi := &file_openshell_proto_msgTypes[38] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2661,7 +2899,7 @@ func (x *CreateSshSessionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateSshSessionResponse.ProtoReflect.Descriptor instead. func (*CreateSshSessionResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{36} + return file_openshell_proto_rawDescGZIP(), []int{38} } func (x *CreateSshSessionResponse) GetSandboxId() string { @@ -2732,7 +2970,7 @@ type ExposeServiceRequest struct { func (x *ExposeServiceRequest) Reset() { *x = ExposeServiceRequest{} - mi := &file_openshell_proto_msgTypes[37] + mi := &file_openshell_proto_msgTypes[39] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2744,7 +2982,7 @@ func (x *ExposeServiceRequest) String() string { func (*ExposeServiceRequest) ProtoMessage() {} func (x *ExposeServiceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[37] + mi := &file_openshell_proto_msgTypes[39] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2757,7 +2995,7 @@ func (x *ExposeServiceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ExposeServiceRequest.ProtoReflect.Descriptor instead. func (*ExposeServiceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{37} + return file_openshell_proto_rawDescGZIP(), []int{39} } func (x *ExposeServiceRequest) GetSandbox() string { @@ -2810,7 +3048,7 @@ type GetServiceRequest struct { func (x *GetServiceRequest) Reset() { *x = GetServiceRequest{} - mi := &file_openshell_proto_msgTypes[38] + mi := &file_openshell_proto_msgTypes[40] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2822,7 +3060,7 @@ func (x *GetServiceRequest) String() string { func (*GetServiceRequest) ProtoMessage() {} func (x *GetServiceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[38] + mi := &file_openshell_proto_msgTypes[40] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2835,7 +3073,7 @@ func (x *GetServiceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetServiceRequest.ProtoReflect.Descriptor instead. func (*GetServiceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{38} + return file_openshell_proto_rawDescGZIP(), []int{40} } func (x *GetServiceRequest) GetSandbox() string { @@ -2878,7 +3116,7 @@ type ListServicesRequest struct { func (x *ListServicesRequest) Reset() { *x = ListServicesRequest{} - mi := &file_openshell_proto_msgTypes[39] + mi := &file_openshell_proto_msgTypes[41] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2890,7 +3128,7 @@ func (x *ListServicesRequest) String() string { func (*ListServicesRequest) ProtoMessage() {} func (x *ListServicesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[39] + mi := &file_openshell_proto_msgTypes[41] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2903,7 +3141,7 @@ func (x *ListServicesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListServicesRequest.ProtoReflect.Descriptor instead. func (*ListServicesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{39} + return file_openshell_proto_rawDescGZIP(), []int{41} } func (x *ListServicesRequest) GetSandbox() string { @@ -2951,7 +3189,7 @@ type ListServicesResponse struct { func (x *ListServicesResponse) Reset() { *x = ListServicesResponse{} - mi := &file_openshell_proto_msgTypes[40] + mi := &file_openshell_proto_msgTypes[42] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2963,7 +3201,7 @@ func (x *ListServicesResponse) String() string { func (*ListServicesResponse) ProtoMessage() {} func (x *ListServicesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[40] + mi := &file_openshell_proto_msgTypes[42] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2976,7 +3214,7 @@ func (x *ListServicesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListServicesResponse.ProtoReflect.Descriptor instead. func (*ListServicesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{40} + return file_openshell_proto_rawDescGZIP(), []int{42} } func (x *ListServicesResponse) GetServices() []*ServiceEndpointResponse { @@ -3001,7 +3239,7 @@ type DeleteServiceRequest struct { func (x *DeleteServiceRequest) Reset() { *x = DeleteServiceRequest{} - mi := &file_openshell_proto_msgTypes[41] + mi := &file_openshell_proto_msgTypes[43] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3013,7 +3251,7 @@ func (x *DeleteServiceRequest) String() string { func (*DeleteServiceRequest) ProtoMessage() {} func (x *DeleteServiceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[41] + mi := &file_openshell_proto_msgTypes[43] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3026,7 +3264,7 @@ func (x *DeleteServiceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteServiceRequest.ProtoReflect.Descriptor instead. func (*DeleteServiceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{41} + return file_openshell_proto_rawDescGZIP(), []int{43} } func (x *DeleteServiceRequest) GetSandbox() string { @@ -3061,7 +3299,7 @@ type DeleteServiceResponse struct { func (x *DeleteServiceResponse) Reset() { *x = DeleteServiceResponse{} - mi := &file_openshell_proto_msgTypes[42] + mi := &file_openshell_proto_msgTypes[44] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3073,7 +3311,7 @@ func (x *DeleteServiceResponse) String() string { func (*DeleteServiceResponse) ProtoMessage() {} func (x *DeleteServiceResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[42] + mi := &file_openshell_proto_msgTypes[44] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3086,7 +3324,7 @@ func (x *DeleteServiceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteServiceResponse.ProtoReflect.Descriptor instead. func (*DeleteServiceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{42} + return file_openshell_proto_rawDescGZIP(), []int{44} } func (x *DeleteServiceResponse) GetDeleted() bool { @@ -3117,7 +3355,7 @@ type ServiceEndpoint struct { func (x *ServiceEndpoint) Reset() { *x = ServiceEndpoint{} - mi := &file_openshell_proto_msgTypes[43] + mi := &file_openshell_proto_msgTypes[45] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3129,7 +3367,7 @@ func (x *ServiceEndpoint) String() string { func (*ServiceEndpoint) ProtoMessage() {} func (x *ServiceEndpoint) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[43] + mi := &file_openshell_proto_msgTypes[45] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3142,7 +3380,7 @@ func (x *ServiceEndpoint) ProtoReflect() protoreflect.Message { // Deprecated: Use ServiceEndpoint.ProtoReflect.Descriptor instead. func (*ServiceEndpoint) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{43} + return file_openshell_proto_rawDescGZIP(), []int{45} } func (x *ServiceEndpoint) GetMetadata() *datamodelv1.ObjectMeta { @@ -3198,7 +3436,7 @@ type ServiceEndpointResponse struct { func (x *ServiceEndpointResponse) Reset() { *x = ServiceEndpointResponse{} - mi := &file_openshell_proto_msgTypes[44] + mi := &file_openshell_proto_msgTypes[46] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3210,7 +3448,7 @@ func (x *ServiceEndpointResponse) String() string { func (*ServiceEndpointResponse) ProtoMessage() {} func (x *ServiceEndpointResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[44] + mi := &file_openshell_proto_msgTypes[46] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3223,7 +3461,7 @@ func (x *ServiceEndpointResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ServiceEndpointResponse.ProtoReflect.Descriptor instead. func (*ServiceEndpointResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{44} + return file_openshell_proto_rawDescGZIP(), []int{46} } func (x *ServiceEndpointResponse) GetEndpoint() *ServiceEndpoint { @@ -3251,7 +3489,7 @@ type RevokeSshSessionRequest struct { func (x *RevokeSshSessionRequest) Reset() { *x = RevokeSshSessionRequest{} - mi := &file_openshell_proto_msgTypes[45] + mi := &file_openshell_proto_msgTypes[47] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3263,7 +3501,7 @@ func (x *RevokeSshSessionRequest) String() string { func (*RevokeSshSessionRequest) ProtoMessage() {} func (x *RevokeSshSessionRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[45] + mi := &file_openshell_proto_msgTypes[47] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3276,7 +3514,7 @@ func (x *RevokeSshSessionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RevokeSshSessionRequest.ProtoReflect.Descriptor instead. func (*RevokeSshSessionRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{45} + return file_openshell_proto_rawDescGZIP(), []int{47} } func (x *RevokeSshSessionRequest) GetToken() string { @@ -3297,7 +3535,7 @@ type RevokeSshSessionResponse struct { func (x *RevokeSshSessionResponse) Reset() { *x = RevokeSshSessionResponse{} - mi := &file_openshell_proto_msgTypes[46] + mi := &file_openshell_proto_msgTypes[48] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3309,7 +3547,7 @@ func (x *RevokeSshSessionResponse) String() string { func (*RevokeSshSessionResponse) ProtoMessage() {} func (x *RevokeSshSessionResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[46] + mi := &file_openshell_proto_msgTypes[48] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3322,7 +3560,7 @@ func (x *RevokeSshSessionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RevokeSshSessionResponse.ProtoReflect.Descriptor instead. func (*RevokeSshSessionResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{46} + return file_openshell_proto_rawDescGZIP(), []int{48} } func (x *RevokeSshSessionResponse) GetRevoked() bool { @@ -3359,7 +3597,7 @@ type ExecSandboxRequest struct { func (x *ExecSandboxRequest) Reset() { *x = ExecSandboxRequest{} - mi := &file_openshell_proto_msgTypes[47] + mi := &file_openshell_proto_msgTypes[49] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3371,7 +3609,7 @@ func (x *ExecSandboxRequest) String() string { func (*ExecSandboxRequest) ProtoMessage() {} func (x *ExecSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[47] + mi := &file_openshell_proto_msgTypes[49] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3384,7 +3622,7 @@ func (x *ExecSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxRequest.ProtoReflect.Descriptor instead. func (*ExecSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{47} + return file_openshell_proto_rawDescGZIP(), []int{49} } func (x *ExecSandboxRequest) GetSandboxId() string { @@ -3460,7 +3698,7 @@ type ExecSandboxStdout struct { func (x *ExecSandboxStdout) Reset() { *x = ExecSandboxStdout{} - mi := &file_openshell_proto_msgTypes[48] + mi := &file_openshell_proto_msgTypes[50] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3472,7 +3710,7 @@ func (x *ExecSandboxStdout) String() string { func (*ExecSandboxStdout) ProtoMessage() {} func (x *ExecSandboxStdout) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[48] + mi := &file_openshell_proto_msgTypes[50] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3485,7 +3723,7 @@ func (x *ExecSandboxStdout) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxStdout.ProtoReflect.Descriptor instead. func (*ExecSandboxStdout) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{48} + return file_openshell_proto_rawDescGZIP(), []int{50} } func (x *ExecSandboxStdout) GetData() []byte { @@ -3505,7 +3743,7 @@ type ExecSandboxStderr struct { func (x *ExecSandboxStderr) Reset() { *x = ExecSandboxStderr{} - mi := &file_openshell_proto_msgTypes[49] + mi := &file_openshell_proto_msgTypes[51] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3517,7 +3755,7 @@ func (x *ExecSandboxStderr) String() string { func (*ExecSandboxStderr) ProtoMessage() {} func (x *ExecSandboxStderr) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[49] + mi := &file_openshell_proto_msgTypes[51] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3530,7 +3768,7 @@ func (x *ExecSandboxStderr) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxStderr.ProtoReflect.Descriptor instead. func (*ExecSandboxStderr) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{49} + return file_openshell_proto_rawDescGZIP(), []int{51} } func (x *ExecSandboxStderr) GetData() []byte { @@ -3550,7 +3788,7 @@ type ExecSandboxExit struct { func (x *ExecSandboxExit) Reset() { *x = ExecSandboxExit{} - mi := &file_openshell_proto_msgTypes[50] + mi := &file_openshell_proto_msgTypes[52] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3562,7 +3800,7 @@ func (x *ExecSandboxExit) String() string { func (*ExecSandboxExit) ProtoMessage() {} func (x *ExecSandboxExit) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[50] + mi := &file_openshell_proto_msgTypes[52] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3575,7 +3813,7 @@ func (x *ExecSandboxExit) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxExit.ProtoReflect.Descriptor instead. func (*ExecSandboxExit) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{50} + return file_openshell_proto_rawDescGZIP(), []int{52} } func (x *ExecSandboxExit) GetExitCode() int32 { @@ -3600,7 +3838,7 @@ type ExecSandboxEvent struct { func (x *ExecSandboxEvent) Reset() { *x = ExecSandboxEvent{} - mi := &file_openshell_proto_msgTypes[51] + mi := &file_openshell_proto_msgTypes[53] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3612,7 +3850,7 @@ func (x *ExecSandboxEvent) String() string { func (*ExecSandboxEvent) ProtoMessage() {} func (x *ExecSandboxEvent) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[51] + mi := &file_openshell_proto_msgTypes[53] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3625,7 +3863,7 @@ func (x *ExecSandboxEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxEvent.ProtoReflect.Descriptor instead. func (*ExecSandboxEvent) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{51} + return file_openshell_proto_rawDescGZIP(), []int{53} } func (x *ExecSandboxEvent) GetPayload() isExecSandboxEvent_Payload { @@ -3707,7 +3945,7 @@ type TcpForwardInit struct { func (x *TcpForwardInit) Reset() { *x = TcpForwardInit{} - mi := &file_openshell_proto_msgTypes[52] + mi := &file_openshell_proto_msgTypes[54] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3719,7 +3957,7 @@ func (x *TcpForwardInit) String() string { func (*TcpForwardInit) ProtoMessage() {} func (x *TcpForwardInit) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[52] + mi := &file_openshell_proto_msgTypes[54] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3732,7 +3970,7 @@ func (x *TcpForwardInit) ProtoReflect() protoreflect.Message { // Deprecated: Use TcpForwardInit.ProtoReflect.Descriptor instead. func (*TcpForwardInit) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{52} + return file_openshell_proto_rawDescGZIP(), []int{54} } func (x *TcpForwardInit) GetSandboxId() string { @@ -3811,7 +4049,7 @@ type TcpForwardFrame struct { func (x *TcpForwardFrame) Reset() { *x = TcpForwardFrame{} - mi := &file_openshell_proto_msgTypes[53] + mi := &file_openshell_proto_msgTypes[55] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3823,7 +4061,7 @@ func (x *TcpForwardFrame) String() string { func (*TcpForwardFrame) ProtoMessage() {} func (x *TcpForwardFrame) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[53] + mi := &file_openshell_proto_msgTypes[55] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3836,7 +4074,7 @@ func (x *TcpForwardFrame) ProtoReflect() protoreflect.Message { // Deprecated: Use TcpForwardFrame.ProtoReflect.Descriptor instead. func (*TcpForwardFrame) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{53} + return file_openshell_proto_rawDescGZIP(), []int{55} } func (x *TcpForwardFrame) GetPayload() isTcpForwardFrame_Payload { @@ -3895,7 +4133,7 @@ type ExecSandboxInput struct { func (x *ExecSandboxInput) Reset() { *x = ExecSandboxInput{} - mi := &file_openshell_proto_msgTypes[54] + mi := &file_openshell_proto_msgTypes[56] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3907,7 +4145,7 @@ func (x *ExecSandboxInput) String() string { func (*ExecSandboxInput) ProtoMessage() {} func (x *ExecSandboxInput) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[54] + mi := &file_openshell_proto_msgTypes[56] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3920,7 +4158,7 @@ func (x *ExecSandboxInput) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxInput.ProtoReflect.Descriptor instead. func (*ExecSandboxInput) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{54} + return file_openshell_proto_rawDescGZIP(), []int{56} } func (x *ExecSandboxInput) GetPayload() isExecSandboxInput_Payload { @@ -3993,7 +4231,7 @@ type ExecSandboxWindowResize struct { func (x *ExecSandboxWindowResize) Reset() { *x = ExecSandboxWindowResize{} - mi := &file_openshell_proto_msgTypes[55] + mi := &file_openshell_proto_msgTypes[57] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4005,7 +4243,7 @@ func (x *ExecSandboxWindowResize) String() string { func (*ExecSandboxWindowResize) ProtoMessage() {} func (x *ExecSandboxWindowResize) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[55] + mi := &file_openshell_proto_msgTypes[57] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4018,7 +4256,7 @@ func (x *ExecSandboxWindowResize) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxWindowResize.ProtoReflect.Descriptor instead. func (*ExecSandboxWindowResize) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{55} + return file_openshell_proto_rawDescGZIP(), []int{57} } func (x *ExecSandboxWindowResize) GetCols() uint32 { @@ -4055,7 +4293,7 @@ type SshSession struct { func (x *SshSession) Reset() { *x = SshSession{} - mi := &file_openshell_proto_msgTypes[56] + mi := &file_openshell_proto_msgTypes[58] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4067,7 +4305,7 @@ func (x *SshSession) String() string { func (*SshSession) ProtoMessage() {} func (x *SshSession) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[56] + mi := &file_openshell_proto_msgTypes[58] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4080,7 +4318,7 @@ func (x *SshSession) ProtoReflect() protoreflect.Message { // Deprecated: Use SshSession.ProtoReflect.Descriptor instead. func (*SshSession) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{56} + return file_openshell_proto_rawDescGZIP(), []int{58} } func (x *SshSession) GetMetadata() *datamodelv1.ObjectMeta { @@ -4148,7 +4386,7 @@ type WatchSandboxRequest struct { func (x *WatchSandboxRequest) Reset() { *x = WatchSandboxRequest{} - mi := &file_openshell_proto_msgTypes[57] + mi := &file_openshell_proto_msgTypes[59] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4160,7 +4398,7 @@ func (x *WatchSandboxRequest) String() string { func (*WatchSandboxRequest) ProtoMessage() {} func (x *WatchSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[57] + mi := &file_openshell_proto_msgTypes[59] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4173,7 +4411,7 @@ func (x *WatchSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use WatchSandboxRequest.ProtoReflect.Descriptor instead. func (*WatchSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{57} + return file_openshell_proto_rawDescGZIP(), []int{59} } func (x *WatchSandboxRequest) GetId() string { @@ -4263,7 +4501,7 @@ type SandboxStreamEvent struct { func (x *SandboxStreamEvent) Reset() { *x = SandboxStreamEvent{} - mi := &file_openshell_proto_msgTypes[58] + mi := &file_openshell_proto_msgTypes[60] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4275,7 +4513,7 @@ func (x *SandboxStreamEvent) String() string { func (*SandboxStreamEvent) ProtoMessage() {} func (x *SandboxStreamEvent) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[58] + mi := &file_openshell_proto_msgTypes[60] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4288,7 +4526,7 @@ func (x *SandboxStreamEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxStreamEvent.ProtoReflect.Descriptor instead. func (*SandboxStreamEvent) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{58} + return file_openshell_proto_rawDescGZIP(), []int{60} } func (x *SandboxStreamEvent) GetPayload() isSandboxStreamEvent_Payload { @@ -4401,7 +4639,7 @@ type SandboxLogLine struct { func (x *SandboxLogLine) Reset() { *x = SandboxLogLine{} - mi := &file_openshell_proto_msgTypes[59] + mi := &file_openshell_proto_msgTypes[61] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4413,7 +4651,7 @@ func (x *SandboxLogLine) String() string { func (*SandboxLogLine) ProtoMessage() {} func (x *SandboxLogLine) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[59] + mi := &file_openshell_proto_msgTypes[61] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4426,7 +4664,7 @@ func (x *SandboxLogLine) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxLogLine.ProtoReflect.Descriptor instead. func (*SandboxLogLine) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{59} + return file_openshell_proto_rawDescGZIP(), []int{61} } func (x *SandboxLogLine) GetSandboxId() string { @@ -4487,7 +4725,7 @@ type SandboxStreamWarning struct { func (x *SandboxStreamWarning) Reset() { *x = SandboxStreamWarning{} - mi := &file_openshell_proto_msgTypes[60] + mi := &file_openshell_proto_msgTypes[62] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4499,7 +4737,7 @@ func (x *SandboxStreamWarning) String() string { func (*SandboxStreamWarning) ProtoMessage() {} func (x *SandboxStreamWarning) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[60] + mi := &file_openshell_proto_msgTypes[62] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4512,7 +4750,7 @@ func (x *SandboxStreamWarning) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxStreamWarning.ProtoReflect.Descriptor instead. func (*SandboxStreamWarning) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{60} + return file_openshell_proto_rawDescGZIP(), []int{62} } func (x *SandboxStreamWarning) GetMessage() string { @@ -4534,7 +4772,7 @@ type CreateProviderRequest struct { func (x *CreateProviderRequest) Reset() { *x = CreateProviderRequest{} - mi := &file_openshell_proto_msgTypes[61] + mi := &file_openshell_proto_msgTypes[63] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4546,7 +4784,7 @@ func (x *CreateProviderRequest) String() string { func (*CreateProviderRequest) ProtoMessage() {} func (x *CreateProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[61] + mi := &file_openshell_proto_msgTypes[63] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4559,7 +4797,7 @@ func (x *CreateProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateProviderRequest.ProtoReflect.Descriptor instead. func (*CreateProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{61} + return file_openshell_proto_rawDescGZIP(), []int{63} } func (x *CreateProviderRequest) GetProvider() *datamodelv1.Provider { @@ -4588,7 +4826,7 @@ type GetProviderRequest struct { func (x *GetProviderRequest) Reset() { *x = GetProviderRequest{} - mi := &file_openshell_proto_msgTypes[62] + mi := &file_openshell_proto_msgTypes[64] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4600,7 +4838,7 @@ func (x *GetProviderRequest) String() string { func (*GetProviderRequest) ProtoMessage() {} func (x *GetProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[62] + mi := &file_openshell_proto_msgTypes[64] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4613,7 +4851,7 @@ func (x *GetProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderRequest.ProtoReflect.Descriptor instead. func (*GetProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{62} + return file_openshell_proto_rawDescGZIP(), []int{64} } func (x *GetProviderRequest) GetName() string { @@ -4645,7 +4883,7 @@ type ListProvidersRequest struct { func (x *ListProvidersRequest) Reset() { *x = ListProvidersRequest{} - mi := &file_openshell_proto_msgTypes[63] + mi := &file_openshell_proto_msgTypes[65] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4657,7 +4895,7 @@ func (x *ListProvidersRequest) String() string { func (*ListProvidersRequest) ProtoMessage() {} func (x *ListProvidersRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[63] + mi := &file_openshell_proto_msgTypes[65] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4670,7 +4908,7 @@ func (x *ListProvidersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProvidersRequest.ProtoReflect.Descriptor instead. func (*ListProvidersRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{63} + return file_openshell_proto_rawDescGZIP(), []int{65} } func (x *ListProvidersRequest) GetLimit() uint32 { @@ -4716,7 +4954,7 @@ type UpdateProviderRequest struct { func (x *UpdateProviderRequest) Reset() { *x = UpdateProviderRequest{} - mi := &file_openshell_proto_msgTypes[64] + mi := &file_openshell_proto_msgTypes[66] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4728,7 +4966,7 @@ func (x *UpdateProviderRequest) String() string { func (*UpdateProviderRequest) ProtoMessage() {} func (x *UpdateProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[64] + mi := &file_openshell_proto_msgTypes[66] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4741,7 +4979,7 @@ func (x *UpdateProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateProviderRequest.ProtoReflect.Descriptor instead. func (*UpdateProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{64} + return file_openshell_proto_rawDescGZIP(), []int{66} } func (x *UpdateProviderRequest) GetProvider() *datamodelv1.Provider { @@ -4777,7 +5015,7 @@ type DeleteProviderRequest struct { func (x *DeleteProviderRequest) Reset() { *x = DeleteProviderRequest{} - mi := &file_openshell_proto_msgTypes[65] + mi := &file_openshell_proto_msgTypes[67] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4789,7 +5027,7 @@ func (x *DeleteProviderRequest) String() string { func (*DeleteProviderRequest) ProtoMessage() {} func (x *DeleteProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[65] + mi := &file_openshell_proto_msgTypes[67] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4802,7 +5040,7 @@ func (x *DeleteProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderRequest.ProtoReflect.Descriptor instead. func (*DeleteProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{65} + return file_openshell_proto_rawDescGZIP(), []int{67} } func (x *DeleteProviderRequest) GetName() string { @@ -4829,7 +5067,7 @@ type ProviderResponse struct { func (x *ProviderResponse) Reset() { *x = ProviderResponse{} - mi := &file_openshell_proto_msgTypes[66] + mi := &file_openshell_proto_msgTypes[68] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4841,7 +5079,7 @@ func (x *ProviderResponse) String() string { func (*ProviderResponse) ProtoMessage() {} func (x *ProviderResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[66] + mi := &file_openshell_proto_msgTypes[68] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4854,7 +5092,7 @@ func (x *ProviderResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderResponse.ProtoReflect.Descriptor instead. func (*ProviderResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{66} + return file_openshell_proto_rawDescGZIP(), []int{68} } func (x *ProviderResponse) GetProvider() *datamodelv1.Provider { @@ -4874,7 +5112,7 @@ type ListProvidersResponse struct { func (x *ListProvidersResponse) Reset() { *x = ListProvidersResponse{} - mi := &file_openshell_proto_msgTypes[67] + mi := &file_openshell_proto_msgTypes[69] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4886,7 +5124,7 @@ func (x *ListProvidersResponse) String() string { func (*ListProvidersResponse) ProtoMessage() {} func (x *ListProvidersResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[67] + mi := &file_openshell_proto_msgTypes[69] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4899,7 +5137,7 @@ func (x *ListProvidersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProvidersResponse.ProtoReflect.Descriptor instead. func (*ListProvidersResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{67} + return file_openshell_proto_rawDescGZIP(), []int{69} } func (x *ListProvidersResponse) GetProviders() []*datamodelv1.Provider { @@ -4923,7 +5161,7 @@ type ListProviderProfilesRequest struct { func (x *ListProviderProfilesRequest) Reset() { *x = ListProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[68] + mi := &file_openshell_proto_msgTypes[70] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4935,7 +5173,7 @@ func (x *ListProviderProfilesRequest) String() string { func (*ListProviderProfilesRequest) ProtoMessage() {} func (x *ListProviderProfilesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[68] + mi := &file_openshell_proto_msgTypes[70] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4948,7 +5186,7 @@ func (x *ListProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*ListProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{68} + return file_openshell_proto_rawDescGZIP(), []int{70} } func (x *ListProviderProfilesRequest) GetLimit() uint32 { @@ -4986,7 +5224,7 @@ type GetProviderProfileRequest struct { func (x *GetProviderProfileRequest) Reset() { *x = GetProviderProfileRequest{} - mi := &file_openshell_proto_msgTypes[69] + mi := &file_openshell_proto_msgTypes[71] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4998,7 +5236,7 @@ func (x *GetProviderProfileRequest) String() string { func (*GetProviderProfileRequest) ProtoMessage() {} func (x *GetProviderProfileRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[69] + mi := &file_openshell_proto_msgTypes[71] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5011,7 +5249,7 @@ func (x *GetProviderProfileRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderProfileRequest.ProtoReflect.Descriptor instead. func (*GetProviderProfileRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{69} + return file_openshell_proto_rawDescGZIP(), []int{71} } func (x *GetProviderProfileRequest) GetId() string { @@ -5039,7 +5277,7 @@ type ProviderProfileImportItem struct { func (x *ProviderProfileImportItem) Reset() { *x = ProviderProfileImportItem{} - mi := &file_openshell_proto_msgTypes[70] + mi := &file_openshell_proto_msgTypes[72] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5051,7 +5289,7 @@ func (x *ProviderProfileImportItem) String() string { func (*ProviderProfileImportItem) ProtoMessage() {} func (x *ProviderProfileImportItem) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[70] + mi := &file_openshell_proto_msgTypes[72] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5064,7 +5302,7 @@ func (x *ProviderProfileImportItem) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileImportItem.ProtoReflect.Descriptor instead. func (*ProviderProfileImportItem) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{70} + return file_openshell_proto_rawDescGZIP(), []int{72} } func (x *ProviderProfileImportItem) GetProfile() *ProviderProfile { @@ -5095,7 +5333,7 @@ type ProviderProfileDiagnostic struct { func (x *ProviderProfileDiagnostic) Reset() { *x = ProviderProfileDiagnostic{} - mi := &file_openshell_proto_msgTypes[71] + mi := &file_openshell_proto_msgTypes[73] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5107,7 +5345,7 @@ func (x *ProviderProfileDiagnostic) String() string { func (*ProviderProfileDiagnostic) ProtoMessage() {} func (x *ProviderProfileDiagnostic) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[71] + mi := &file_openshell_proto_msgTypes[73] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5120,7 +5358,7 @@ func (x *ProviderProfileDiagnostic) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileDiagnostic.ProtoReflect.Descriptor instead. func (*ProviderProfileDiagnostic) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{71} + return file_openshell_proto_rawDescGZIP(), []int{73} } func (x *ProviderProfileDiagnostic) GetSource() string { @@ -5177,7 +5415,7 @@ type ProviderCredentialTokenGrantAudienceOverride struct { func (x *ProviderCredentialTokenGrantAudienceOverride) Reset() { *x = ProviderCredentialTokenGrantAudienceOverride{} - mi := &file_openshell_proto_msgTypes[72] + mi := &file_openshell_proto_msgTypes[74] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5189,7 +5427,7 @@ func (x *ProviderCredentialTokenGrantAudienceOverride) String() string { func (*ProviderCredentialTokenGrantAudienceOverride) ProtoMessage() {} func (x *ProviderCredentialTokenGrantAudienceOverride) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[72] + mi := &file_openshell_proto_msgTypes[74] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5202,7 +5440,7 @@ func (x *ProviderCredentialTokenGrantAudienceOverride) ProtoReflect() protorefle // Deprecated: Use ProviderCredentialTokenGrantAudienceOverride.ProtoReflect.Descriptor instead. func (*ProviderCredentialTokenGrantAudienceOverride) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{72} + return file_openshell_proto_rawDescGZIP(), []int{74} } func (x *ProviderCredentialTokenGrantAudienceOverride) GetHost() string { @@ -5267,7 +5505,7 @@ type ProviderCredentialTokenGrant struct { func (x *ProviderCredentialTokenGrant) Reset() { *x = ProviderCredentialTokenGrant{} - mi := &file_openshell_proto_msgTypes[73] + mi := &file_openshell_proto_msgTypes[75] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5279,7 +5517,7 @@ func (x *ProviderCredentialTokenGrant) String() string { func (*ProviderCredentialTokenGrant) ProtoMessage() {} func (x *ProviderCredentialTokenGrant) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[73] + mi := &file_openshell_proto_msgTypes[75] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5292,7 +5530,7 @@ func (x *ProviderCredentialTokenGrant) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialTokenGrant.ProtoReflect.Descriptor instead. func (*ProviderCredentialTokenGrant) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{73} + return file_openshell_proto_rawDescGZIP(), []int{75} } func (x *ProviderCredentialTokenGrant) GetTokenEndpoint() string { @@ -5363,7 +5601,7 @@ type ProviderProfileCredential struct { func (x *ProviderProfileCredential) Reset() { *x = ProviderProfileCredential{} - mi := &file_openshell_proto_msgTypes[74] + mi := &file_openshell_proto_msgTypes[76] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5375,7 +5613,7 @@ func (x *ProviderProfileCredential) String() string { func (*ProviderProfileCredential) ProtoMessage() {} func (x *ProviderProfileCredential) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[74] + mi := &file_openshell_proto_msgTypes[76] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5388,7 +5626,7 @@ func (x *ProviderProfileCredential) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileCredential.ProtoReflect.Descriptor instead. func (*ProviderProfileCredential) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{74} + return file_openshell_proto_rawDescGZIP(), []int{76} } func (x *ProviderProfileCredential) GetName() string { @@ -5473,7 +5711,7 @@ type ProviderCredentialRefreshMaterial struct { func (x *ProviderCredentialRefreshMaterial) Reset() { *x = ProviderCredentialRefreshMaterial{} - mi := &file_openshell_proto_msgTypes[75] + mi := &file_openshell_proto_msgTypes[77] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5485,7 +5723,7 @@ func (x *ProviderCredentialRefreshMaterial) String() string { func (*ProviderCredentialRefreshMaterial) ProtoMessage() {} func (x *ProviderCredentialRefreshMaterial) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[75] + mi := &file_openshell_proto_msgTypes[77] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5498,7 +5736,7 @@ func (x *ProviderCredentialRefreshMaterial) ProtoReflect() protoreflect.Message // Deprecated: Use ProviderCredentialRefreshMaterial.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefreshMaterial) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{75} + return file_openshell_proto_rawDescGZIP(), []int{77} } func (x *ProviderCredentialRefreshMaterial) GetName() string { @@ -5543,7 +5781,7 @@ type ProviderCredentialRefreshOutput struct { func (x *ProviderCredentialRefreshOutput) Reset() { *x = ProviderCredentialRefreshOutput{} - mi := &file_openshell_proto_msgTypes[76] + mi := &file_openshell_proto_msgTypes[78] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5555,7 +5793,7 @@ func (x *ProviderCredentialRefreshOutput) String() string { func (*ProviderCredentialRefreshOutput) ProtoMessage() {} func (x *ProviderCredentialRefreshOutput) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[76] + mi := &file_openshell_proto_msgTypes[78] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5568,7 +5806,7 @@ func (x *ProviderCredentialRefreshOutput) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialRefreshOutput.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefreshOutput) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{76} + return file_openshell_proto_rawDescGZIP(), []int{78} } func (x *ProviderCredentialRefreshOutput) GetOutput() string { @@ -5600,7 +5838,7 @@ type ProviderCredentialRefresh struct { func (x *ProviderCredentialRefresh) Reset() { *x = ProviderCredentialRefresh{} - mi := &file_openshell_proto_msgTypes[77] + mi := &file_openshell_proto_msgTypes[79] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5612,7 +5850,7 @@ func (x *ProviderCredentialRefresh) String() string { func (*ProviderCredentialRefresh) ProtoMessage() {} func (x *ProviderCredentialRefresh) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[77] + mi := &file_openshell_proto_msgTypes[79] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5625,7 +5863,7 @@ func (x *ProviderCredentialRefresh) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialRefresh.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefresh) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{77} + return file_openshell_proto_rawDescGZIP(), []int{79} } func (x *ProviderCredentialRefresh) GetStrategy() ProviderCredentialRefreshStrategy { @@ -5694,7 +5932,7 @@ type ProviderCredentialRefreshStatus struct { func (x *ProviderCredentialRefreshStatus) Reset() { *x = ProviderCredentialRefreshStatus{} - mi := &file_openshell_proto_msgTypes[78] + mi := &file_openshell_proto_msgTypes[80] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5706,7 +5944,7 @@ func (x *ProviderCredentialRefreshStatus) String() string { func (*ProviderCredentialRefreshStatus) ProtoMessage() {} func (x *ProviderCredentialRefreshStatus) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[78] + mi := &file_openshell_proto_msgTypes[80] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5719,7 +5957,7 @@ func (x *ProviderCredentialRefreshStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialRefreshStatus.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefreshStatus) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{78} + return file_openshell_proto_rawDescGZIP(), []int{80} } func (x *ProviderCredentialRefreshStatus) GetProviderName() string { @@ -5796,7 +6034,7 @@ type ProviderProfileDiscovery struct { func (x *ProviderProfileDiscovery) Reset() { *x = ProviderProfileDiscovery{} - mi := &file_openshell_proto_msgTypes[79] + mi := &file_openshell_proto_msgTypes[81] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5808,7 +6046,7 @@ func (x *ProviderProfileDiscovery) String() string { func (*ProviderProfileDiscovery) ProtoMessage() {} func (x *ProviderProfileDiscovery) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[79] + mi := &file_openshell_proto_msgTypes[81] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5821,7 +6059,7 @@ func (x *ProviderProfileDiscovery) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileDiscovery.ProtoReflect.Descriptor instead. func (*ProviderProfileDiscovery) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{79} + return file_openshell_proto_rawDescGZIP(), []int{81} } func (x *ProviderProfileDiscovery) GetCredentials() []string { @@ -5865,7 +6103,7 @@ type StoredProviderCredentialRefreshState struct { func (x *StoredProviderCredentialRefreshState) Reset() { *x = StoredProviderCredentialRefreshState{} - mi := &file_openshell_proto_msgTypes[80] + mi := &file_openshell_proto_msgTypes[82] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5877,7 +6115,7 @@ func (x *StoredProviderCredentialRefreshState) String() string { func (*StoredProviderCredentialRefreshState) ProtoMessage() {} func (x *StoredProviderCredentialRefreshState) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[80] + mi := &file_openshell_proto_msgTypes[82] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5890,7 +6128,7 @@ func (x *StoredProviderCredentialRefreshState) ProtoReflect() protoreflect.Messa // Deprecated: Use StoredProviderCredentialRefreshState.ProtoReflect.Descriptor instead. func (*StoredProviderCredentialRefreshState) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{80} + return file_openshell_proto_rawDescGZIP(), []int{82} } func (x *StoredProviderCredentialRefreshState) GetMetadata() *datamodelv1.ObjectMeta { @@ -6031,7 +6269,7 @@ type GetProviderRefreshStatusRequest struct { func (x *GetProviderRefreshStatusRequest) Reset() { *x = GetProviderRefreshStatusRequest{} - mi := &file_openshell_proto_msgTypes[81] + mi := &file_openshell_proto_msgTypes[83] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6043,7 +6281,7 @@ func (x *GetProviderRefreshStatusRequest) String() string { func (*GetProviderRefreshStatusRequest) ProtoMessage() {} func (x *GetProviderRefreshStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[81] + mi := &file_openshell_proto_msgTypes[83] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6056,7 +6294,7 @@ func (x *GetProviderRefreshStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderRefreshStatusRequest.ProtoReflect.Descriptor instead. func (*GetProviderRefreshStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{81} + return file_openshell_proto_rawDescGZIP(), []int{83} } func (x *GetProviderRefreshStatusRequest) GetProvider() string { @@ -6089,7 +6327,7 @@ type GetProviderRefreshStatusResponse struct { func (x *GetProviderRefreshStatusResponse) Reset() { *x = GetProviderRefreshStatusResponse{} - mi := &file_openshell_proto_msgTypes[82] + mi := &file_openshell_proto_msgTypes[84] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6101,7 +6339,7 @@ func (x *GetProviderRefreshStatusResponse) String() string { func (*GetProviderRefreshStatusResponse) ProtoMessage() {} func (x *GetProviderRefreshStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[82] + mi := &file_openshell_proto_msgTypes[84] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6114,7 +6352,7 @@ func (x *GetProviderRefreshStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderRefreshStatusResponse.ProtoReflect.Descriptor instead. func (*GetProviderRefreshStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{82} + return file_openshell_proto_rawDescGZIP(), []int{84} } func (x *GetProviderRefreshStatusResponse) GetCredentials() []*ProviderCredentialRefreshStatus { @@ -6140,7 +6378,7 @@ type ConfigureProviderRefreshRequest struct { func (x *ConfigureProviderRefreshRequest) Reset() { *x = ConfigureProviderRefreshRequest{} - mi := &file_openshell_proto_msgTypes[83] + mi := &file_openshell_proto_msgTypes[85] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6152,7 +6390,7 @@ func (x *ConfigureProviderRefreshRequest) String() string { func (*ConfigureProviderRefreshRequest) ProtoMessage() {} func (x *ConfigureProviderRefreshRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[83] + mi := &file_openshell_proto_msgTypes[85] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6165,7 +6403,7 @@ func (x *ConfigureProviderRefreshRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ConfigureProviderRefreshRequest.ProtoReflect.Descriptor instead. func (*ConfigureProviderRefreshRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{83} + return file_openshell_proto_rawDescGZIP(), []int{85} } func (x *ConfigureProviderRefreshRequest) GetProvider() string { @@ -6226,7 +6464,7 @@ type ConfigureProviderRefreshResponse struct { func (x *ConfigureProviderRefreshResponse) Reset() { *x = ConfigureProviderRefreshResponse{} - mi := &file_openshell_proto_msgTypes[84] + mi := &file_openshell_proto_msgTypes[86] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6238,7 +6476,7 @@ func (x *ConfigureProviderRefreshResponse) String() string { func (*ConfigureProviderRefreshResponse) ProtoMessage() {} func (x *ConfigureProviderRefreshResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[84] + mi := &file_openshell_proto_msgTypes[86] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6251,7 +6489,7 @@ func (x *ConfigureProviderRefreshResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ConfigureProviderRefreshResponse.ProtoReflect.Descriptor instead. func (*ConfigureProviderRefreshResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{84} + return file_openshell_proto_rawDescGZIP(), []int{86} } func (x *ConfigureProviderRefreshResponse) GetStatus() *ProviderCredentialRefreshStatus { @@ -6273,7 +6511,7 @@ type RotateProviderCredentialRequest struct { func (x *RotateProviderCredentialRequest) Reset() { *x = RotateProviderCredentialRequest{} - mi := &file_openshell_proto_msgTypes[85] + mi := &file_openshell_proto_msgTypes[87] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6285,7 +6523,7 @@ func (x *RotateProviderCredentialRequest) String() string { func (*RotateProviderCredentialRequest) ProtoMessage() {} func (x *RotateProviderCredentialRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[85] + mi := &file_openshell_proto_msgTypes[87] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6298,7 +6536,7 @@ func (x *RotateProviderCredentialRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RotateProviderCredentialRequest.ProtoReflect.Descriptor instead. func (*RotateProviderCredentialRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{85} + return file_openshell_proto_rawDescGZIP(), []int{87} } func (x *RotateProviderCredentialRequest) GetProvider() string { @@ -6331,7 +6569,7 @@ type RotateProviderCredentialResponse struct { func (x *RotateProviderCredentialResponse) Reset() { *x = RotateProviderCredentialResponse{} - mi := &file_openshell_proto_msgTypes[86] + mi := &file_openshell_proto_msgTypes[88] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6343,7 +6581,7 @@ func (x *RotateProviderCredentialResponse) String() string { func (*RotateProviderCredentialResponse) ProtoMessage() {} func (x *RotateProviderCredentialResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[86] + mi := &file_openshell_proto_msgTypes[88] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6356,7 +6594,7 @@ func (x *RotateProviderCredentialResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RotateProviderCredentialResponse.ProtoReflect.Descriptor instead. func (*RotateProviderCredentialResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{86} + return file_openshell_proto_rawDescGZIP(), []int{88} } func (x *RotateProviderCredentialResponse) GetStatus() *ProviderCredentialRefreshStatus { @@ -6378,7 +6616,7 @@ type DeleteProviderRefreshRequest struct { func (x *DeleteProviderRefreshRequest) Reset() { *x = DeleteProviderRefreshRequest{} - mi := &file_openshell_proto_msgTypes[87] + mi := &file_openshell_proto_msgTypes[89] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6390,7 +6628,7 @@ func (x *DeleteProviderRefreshRequest) String() string { func (*DeleteProviderRefreshRequest) ProtoMessage() {} func (x *DeleteProviderRefreshRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[87] + mi := &file_openshell_proto_msgTypes[89] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6403,7 +6641,7 @@ func (x *DeleteProviderRefreshRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderRefreshRequest.ProtoReflect.Descriptor instead. func (*DeleteProviderRefreshRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{87} + return file_openshell_proto_rawDescGZIP(), []int{89} } func (x *DeleteProviderRefreshRequest) GetProvider() string { @@ -6436,7 +6674,7 @@ type DeleteProviderRefreshResponse struct { func (x *DeleteProviderRefreshResponse) Reset() { *x = DeleteProviderRefreshResponse{} - mi := &file_openshell_proto_msgTypes[88] + mi := &file_openshell_proto_msgTypes[90] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6448,7 +6686,7 @@ func (x *DeleteProviderRefreshResponse) String() string { func (*DeleteProviderRefreshResponse) ProtoMessage() {} func (x *DeleteProviderRefreshResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[88] + mi := &file_openshell_proto_msgTypes[90] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6461,7 +6699,7 @@ func (x *DeleteProviderRefreshResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderRefreshResponse.ProtoReflect.Descriptor instead. func (*DeleteProviderRefreshResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{88} + return file_openshell_proto_rawDescGZIP(), []int{90} } func (x *DeleteProviderRefreshResponse) GetDeleted() bool { @@ -6501,7 +6739,7 @@ type ProviderProfile struct { func (x *ProviderProfile) Reset() { *x = ProviderProfile{} - mi := &file_openshell_proto_msgTypes[89] + mi := &file_openshell_proto_msgTypes[91] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6513,7 +6751,7 @@ func (x *ProviderProfile) String() string { func (*ProviderProfile) ProtoMessage() {} func (x *ProviderProfile) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[89] + mi := &file_openshell_proto_msgTypes[91] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6526,7 +6764,7 @@ func (x *ProviderProfile) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfile.ProtoReflect.Descriptor instead. func (*ProviderProfile) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{89} + return file_openshell_proto_rawDescGZIP(), []int{91} } func (x *ProviderProfile) GetId() string { @@ -6631,7 +6869,7 @@ type StoredProviderProfile struct { func (x *StoredProviderProfile) Reset() { *x = StoredProviderProfile{} - mi := &file_openshell_proto_msgTypes[90] + mi := &file_openshell_proto_msgTypes[92] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6643,7 +6881,7 @@ func (x *StoredProviderProfile) String() string { func (*StoredProviderProfile) ProtoMessage() {} func (x *StoredProviderProfile) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[90] + mi := &file_openshell_proto_msgTypes[92] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6656,7 +6894,7 @@ func (x *StoredProviderProfile) ProtoReflect() protoreflect.Message { // Deprecated: Use StoredProviderProfile.ProtoReflect.Descriptor instead. func (*StoredProviderProfile) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{90} + return file_openshell_proto_rawDescGZIP(), []int{92} } func (x *StoredProviderProfile) GetMetadata() *datamodelv1.ObjectMeta { @@ -6683,7 +6921,7 @@ type ProviderProfileResponse struct { func (x *ProviderProfileResponse) Reset() { *x = ProviderProfileResponse{} - mi := &file_openshell_proto_msgTypes[91] + mi := &file_openshell_proto_msgTypes[93] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6695,7 +6933,7 @@ func (x *ProviderProfileResponse) String() string { func (*ProviderProfileResponse) ProtoMessage() {} func (x *ProviderProfileResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[91] + mi := &file_openshell_proto_msgTypes[93] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6708,7 +6946,7 @@ func (x *ProviderProfileResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileResponse.ProtoReflect.Descriptor instead. func (*ProviderProfileResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{91} + return file_openshell_proto_rawDescGZIP(), []int{93} } func (x *ProviderProfileResponse) GetProfile() *ProviderProfile { @@ -6728,7 +6966,7 @@ type ListProviderProfilesResponse struct { func (x *ListProviderProfilesResponse) Reset() { *x = ListProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[92] + mi := &file_openshell_proto_msgTypes[94] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6740,7 +6978,7 @@ func (x *ListProviderProfilesResponse) String() string { func (*ListProviderProfilesResponse) ProtoMessage() {} func (x *ListProviderProfilesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[92] + mi := &file_openshell_proto_msgTypes[94] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6753,7 +6991,7 @@ func (x *ListProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*ListProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{92} + return file_openshell_proto_rawDescGZIP(), []int{94} } func (x *ListProviderProfilesResponse) GetProfiles() []*ProviderProfile { @@ -6776,7 +7014,7 @@ type ImportProviderProfilesRequest struct { func (x *ImportProviderProfilesRequest) Reset() { *x = ImportProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[93] + mi := &file_openshell_proto_msgTypes[95] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6788,7 +7026,7 @@ func (x *ImportProviderProfilesRequest) String() string { func (*ImportProviderProfilesRequest) ProtoMessage() {} func (x *ImportProviderProfilesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[93] + mi := &file_openshell_proto_msgTypes[95] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6801,7 +7039,7 @@ func (x *ImportProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ImportProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*ImportProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{93} + return file_openshell_proto_rawDescGZIP(), []int{95} } func (x *ImportProviderProfilesRequest) GetProfiles() []*ProviderProfileImportItem { @@ -6830,7 +7068,7 @@ type ImportProviderProfilesResponse struct { func (x *ImportProviderProfilesResponse) Reset() { *x = ImportProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[94] + mi := &file_openshell_proto_msgTypes[96] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6842,7 +7080,7 @@ func (x *ImportProviderProfilesResponse) String() string { func (*ImportProviderProfilesResponse) ProtoMessage() {} func (x *ImportProviderProfilesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[94] + mi := &file_openshell_proto_msgTypes[96] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6855,7 +7093,7 @@ func (x *ImportProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ImportProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*ImportProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{94} + return file_openshell_proto_rawDescGZIP(), []int{96} } func (x *ImportProviderProfilesResponse) GetDiagnostics() []*ProviderProfileDiagnostic { @@ -6899,7 +7137,7 @@ type UpdateProviderProfilesRequest struct { func (x *UpdateProviderProfilesRequest) Reset() { *x = UpdateProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[95] + mi := &file_openshell_proto_msgTypes[97] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6911,7 +7149,7 @@ func (x *UpdateProviderProfilesRequest) String() string { func (*UpdateProviderProfilesRequest) ProtoMessage() {} func (x *UpdateProviderProfilesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[95] + mi := &file_openshell_proto_msgTypes[97] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6924,7 +7162,7 @@ func (x *UpdateProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*UpdateProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{95} + return file_openshell_proto_rawDescGZIP(), []int{97} } func (x *UpdateProviderProfilesRequest) GetProfile() *ProviderProfileImportItem { @@ -6967,7 +7205,7 @@ type UpdateProviderProfilesResponse struct { func (x *UpdateProviderProfilesResponse) Reset() { *x = UpdateProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[96] + mi := &file_openshell_proto_msgTypes[98] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6979,7 +7217,7 @@ func (x *UpdateProviderProfilesResponse) String() string { func (*UpdateProviderProfilesResponse) ProtoMessage() {} func (x *UpdateProviderProfilesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[96] + mi := &file_openshell_proto_msgTypes[98] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6992,7 +7230,7 @@ func (x *UpdateProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*UpdateProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{96} + return file_openshell_proto_rawDescGZIP(), []int{98} } func (x *UpdateProviderProfilesResponse) GetDiagnostics() []*ProviderProfileDiagnostic { @@ -7029,7 +7267,7 @@ type LintProviderProfilesRequest struct { func (x *LintProviderProfilesRequest) Reset() { *x = LintProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[97] + mi := &file_openshell_proto_msgTypes[99] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7041,7 +7279,7 @@ func (x *LintProviderProfilesRequest) String() string { func (*LintProviderProfilesRequest) ProtoMessage() {} func (x *LintProviderProfilesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[97] + mi := &file_openshell_proto_msgTypes[99] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7054,7 +7292,7 @@ func (x *LintProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use LintProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*LintProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{97} + return file_openshell_proto_rawDescGZIP(), []int{99} } func (x *LintProviderProfilesRequest) GetProfiles() []*ProviderProfileImportItem { @@ -7082,7 +7320,7 @@ type LintProviderProfilesResponse struct { func (x *LintProviderProfilesResponse) Reset() { *x = LintProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[98] + mi := &file_openshell_proto_msgTypes[100] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7094,7 +7332,7 @@ func (x *LintProviderProfilesResponse) String() string { func (*LintProviderProfilesResponse) ProtoMessage() {} func (x *LintProviderProfilesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[98] + mi := &file_openshell_proto_msgTypes[100] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7107,7 +7345,7 @@ func (x *LintProviderProfilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use LintProviderProfilesResponse.ProtoReflect.Descriptor instead. func (*LintProviderProfilesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{98} + return file_openshell_proto_rawDescGZIP(), []int{100} } func (x *LintProviderProfilesResponse) GetDiagnostics() []*ProviderProfileDiagnostic { @@ -7134,7 +7372,7 @@ type DeleteProviderResponse struct { func (x *DeleteProviderResponse) Reset() { *x = DeleteProviderResponse{} - mi := &file_openshell_proto_msgTypes[99] + mi := &file_openshell_proto_msgTypes[101] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7146,7 +7384,7 @@ func (x *DeleteProviderResponse) String() string { func (*DeleteProviderResponse) ProtoMessage() {} func (x *DeleteProviderResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[99] + mi := &file_openshell_proto_msgTypes[101] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7159,7 +7397,7 @@ func (x *DeleteProviderResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderResponse.ProtoReflect.Descriptor instead. func (*DeleteProviderResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{99} + return file_openshell_proto_rawDescGZIP(), []int{101} } func (x *DeleteProviderResponse) GetDeleted() bool { @@ -7182,7 +7420,7 @@ type DeleteProviderProfileRequest struct { func (x *DeleteProviderProfileRequest) Reset() { *x = DeleteProviderProfileRequest{} - mi := &file_openshell_proto_msgTypes[100] + mi := &file_openshell_proto_msgTypes[102] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7194,7 +7432,7 @@ func (x *DeleteProviderProfileRequest) String() string { func (*DeleteProviderProfileRequest) ProtoMessage() {} func (x *DeleteProviderProfileRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[100] + mi := &file_openshell_proto_msgTypes[102] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7207,7 +7445,7 @@ func (x *DeleteProviderProfileRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderProfileRequest.ProtoReflect.Descriptor instead. func (*DeleteProviderProfileRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{100} + return file_openshell_proto_rawDescGZIP(), []int{102} } func (x *DeleteProviderProfileRequest) GetId() string { @@ -7234,7 +7472,7 @@ type DeleteProviderProfileResponse struct { func (x *DeleteProviderProfileResponse) Reset() { *x = DeleteProviderProfileResponse{} - mi := &file_openshell_proto_msgTypes[101] + mi := &file_openshell_proto_msgTypes[103] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7246,7 +7484,7 @@ func (x *DeleteProviderProfileResponse) String() string { func (*DeleteProviderProfileResponse) ProtoMessage() {} func (x *DeleteProviderProfileResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[101] + mi := &file_openshell_proto_msgTypes[103] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7259,7 +7497,7 @@ func (x *DeleteProviderProfileResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderProfileResponse.ProtoReflect.Descriptor instead. func (*DeleteProviderProfileResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{101} + return file_openshell_proto_rawDescGZIP(), []int{103} } func (x *DeleteProviderProfileResponse) GetDeleted() bool { @@ -7284,7 +7522,7 @@ type GetSandboxProviderEnvironmentRequest struct { func (x *GetSandboxProviderEnvironmentRequest) Reset() { *x = GetSandboxProviderEnvironmentRequest{} - mi := &file_openshell_proto_msgTypes[102] + mi := &file_openshell_proto_msgTypes[104] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7296,7 +7534,7 @@ func (x *GetSandboxProviderEnvironmentRequest) String() string { func (*GetSandboxProviderEnvironmentRequest) ProtoMessage() {} func (x *GetSandboxProviderEnvironmentRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[102] + mi := &file_openshell_proto_msgTypes[104] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7309,7 +7547,7 @@ func (x *GetSandboxProviderEnvironmentRequest) ProtoReflect() protoreflect.Messa // Deprecated: Use GetSandboxProviderEnvironmentRequest.ProtoReflect.Descriptor instead. func (*GetSandboxProviderEnvironmentRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{102} + return file_openshell_proto_rawDescGZIP(), []int{104} } func (x *GetSandboxProviderEnvironmentRequest) GetSandboxId() string { @@ -7338,7 +7576,7 @@ type StaticCredentialEndpointBinding struct { func (x *StaticCredentialEndpointBinding) Reset() { *x = StaticCredentialEndpointBinding{} - mi := &file_openshell_proto_msgTypes[103] + mi := &file_openshell_proto_msgTypes[105] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7350,7 +7588,7 @@ func (x *StaticCredentialEndpointBinding) String() string { func (*StaticCredentialEndpointBinding) ProtoMessage() {} func (x *StaticCredentialEndpointBinding) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[103] + mi := &file_openshell_proto_msgTypes[105] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7363,7 +7601,7 @@ func (x *StaticCredentialEndpointBinding) ProtoReflect() protoreflect.Message { // Deprecated: Use StaticCredentialEndpointBinding.ProtoReflect.Descriptor instead. func (*StaticCredentialEndpointBinding) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{103} + return file_openshell_proto_rawDescGZIP(), []int{105} } func (x *StaticCredentialEndpointBinding) GetHost() string { @@ -7407,7 +7645,7 @@ type StaticCredentialBinding struct { func (x *StaticCredentialBinding) Reset() { *x = StaticCredentialBinding{} - mi := &file_openshell_proto_msgTypes[104] + mi := &file_openshell_proto_msgTypes[106] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7419,7 +7657,7 @@ func (x *StaticCredentialBinding) String() string { func (*StaticCredentialBinding) ProtoMessage() {} func (x *StaticCredentialBinding) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[104] + mi := &file_openshell_proto_msgTypes[106] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7432,7 +7670,7 @@ func (x *StaticCredentialBinding) ProtoReflect() protoreflect.Message { // Deprecated: Use StaticCredentialBinding.ProtoReflect.Descriptor instead. func (*StaticCredentialBinding) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{104} + return file_openshell_proto_rawDescGZIP(), []int{106} } func (x *StaticCredentialBinding) GetEndpoints() []*StaticCredentialEndpointBinding { @@ -7483,7 +7721,7 @@ type GetSandboxProviderEnvironmentResponse struct { func (x *GetSandboxProviderEnvironmentResponse) Reset() { *x = GetSandboxProviderEnvironmentResponse{} - mi := &file_openshell_proto_msgTypes[105] + mi := &file_openshell_proto_msgTypes[107] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7495,7 +7733,7 @@ func (x *GetSandboxProviderEnvironmentResponse) String() string { func (*GetSandboxProviderEnvironmentResponse) ProtoMessage() {} func (x *GetSandboxProviderEnvironmentResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[105] + mi := &file_openshell_proto_msgTypes[107] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7508,7 +7746,7 @@ func (x *GetSandboxProviderEnvironmentResponse) ProtoReflect() protoreflect.Mess // Deprecated: Use GetSandboxProviderEnvironmentResponse.ProtoReflect.Descriptor instead. func (*GetSandboxProviderEnvironmentResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{105} + return file_openshell_proto_rawDescGZIP(), []int{107} } func (x *GetSandboxProviderEnvironmentResponse) GetEnvironment() map[string]string { @@ -7600,7 +7838,7 @@ type UpdateConfigRequest struct { func (x *UpdateConfigRequest) Reset() { *x = UpdateConfigRequest{} - mi := &file_openshell_proto_msgTypes[106] + mi := &file_openshell_proto_msgTypes[108] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7612,7 +7850,7 @@ func (x *UpdateConfigRequest) String() string { func (*UpdateConfigRequest) ProtoMessage() {} func (x *UpdateConfigRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[106] + mi := &file_openshell_proto_msgTypes[108] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7625,7 +7863,7 @@ func (x *UpdateConfigRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateConfigRequest.ProtoReflect.Descriptor instead. func (*UpdateConfigRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{106} + return file_openshell_proto_rawDescGZIP(), []int{108} } func (x *UpdateConfigRequest) GetName() string { @@ -7715,7 +7953,7 @@ type PolicyMergeOperation struct { func (x *PolicyMergeOperation) Reset() { *x = PolicyMergeOperation{} - mi := &file_openshell_proto_msgTypes[107] + mi := &file_openshell_proto_msgTypes[109] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7727,7 +7965,7 @@ func (x *PolicyMergeOperation) String() string { func (*PolicyMergeOperation) ProtoMessage() {} func (x *PolicyMergeOperation) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[107] + mi := &file_openshell_proto_msgTypes[109] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7740,7 +7978,7 @@ func (x *PolicyMergeOperation) ProtoReflect() protoreflect.Message { // Deprecated: Use PolicyMergeOperation.ProtoReflect.Descriptor instead. func (*PolicyMergeOperation) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{107} + return file_openshell_proto_rawDescGZIP(), []int{109} } func (x *PolicyMergeOperation) GetOperation() isPolicyMergeOperation_Operation { @@ -7854,7 +8092,7 @@ type AddNetworkRule struct { func (x *AddNetworkRule) Reset() { *x = AddNetworkRule{} - mi := &file_openshell_proto_msgTypes[108] + mi := &file_openshell_proto_msgTypes[110] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7866,7 +8104,7 @@ func (x *AddNetworkRule) String() string { func (*AddNetworkRule) ProtoMessage() {} func (x *AddNetworkRule) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[108] + mi := &file_openshell_proto_msgTypes[110] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7879,7 +8117,7 @@ func (x *AddNetworkRule) ProtoReflect() protoreflect.Message { // Deprecated: Use AddNetworkRule.ProtoReflect.Descriptor instead. func (*AddNetworkRule) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{108} + return file_openshell_proto_rawDescGZIP(), []int{110} } func (x *AddNetworkRule) GetRuleName() string { @@ -7907,7 +8145,7 @@ type RemoveNetworkEndpoint struct { func (x *RemoveNetworkEndpoint) Reset() { *x = RemoveNetworkEndpoint{} - mi := &file_openshell_proto_msgTypes[109] + mi := &file_openshell_proto_msgTypes[111] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7919,7 +8157,7 @@ func (x *RemoveNetworkEndpoint) String() string { func (*RemoveNetworkEndpoint) ProtoMessage() {} func (x *RemoveNetworkEndpoint) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[109] + mi := &file_openshell_proto_msgTypes[111] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7932,7 +8170,7 @@ func (x *RemoveNetworkEndpoint) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveNetworkEndpoint.ProtoReflect.Descriptor instead. func (*RemoveNetworkEndpoint) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{109} + return file_openshell_proto_rawDescGZIP(), []int{111} } func (x *RemoveNetworkEndpoint) GetRuleName() string { @@ -7965,7 +8203,7 @@ type RemoveNetworkRule struct { func (x *RemoveNetworkRule) Reset() { *x = RemoveNetworkRule{} - mi := &file_openshell_proto_msgTypes[110] + mi := &file_openshell_proto_msgTypes[112] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7977,7 +8215,7 @@ func (x *RemoveNetworkRule) String() string { func (*RemoveNetworkRule) ProtoMessage() {} func (x *RemoveNetworkRule) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[110] + mi := &file_openshell_proto_msgTypes[112] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7990,7 +8228,7 @@ func (x *RemoveNetworkRule) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveNetworkRule.ProtoReflect.Descriptor instead. func (*RemoveNetworkRule) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{110} + return file_openshell_proto_rawDescGZIP(), []int{112} } func (x *RemoveNetworkRule) GetRuleName() string { @@ -8011,7 +8249,7 @@ type AddDenyRules struct { func (x *AddDenyRules) Reset() { *x = AddDenyRules{} - mi := &file_openshell_proto_msgTypes[111] + mi := &file_openshell_proto_msgTypes[113] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8023,7 +8261,7 @@ func (x *AddDenyRules) String() string { func (*AddDenyRules) ProtoMessage() {} func (x *AddDenyRules) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[111] + mi := &file_openshell_proto_msgTypes[113] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8036,7 +8274,7 @@ func (x *AddDenyRules) ProtoReflect() protoreflect.Message { // Deprecated: Use AddDenyRules.ProtoReflect.Descriptor instead. func (*AddDenyRules) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{111} + return file_openshell_proto_rawDescGZIP(), []int{113} } func (x *AddDenyRules) GetHost() string { @@ -8071,7 +8309,7 @@ type AddAllowRules struct { func (x *AddAllowRules) Reset() { *x = AddAllowRules{} - mi := &file_openshell_proto_msgTypes[112] + mi := &file_openshell_proto_msgTypes[114] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8083,7 +8321,7 @@ func (x *AddAllowRules) String() string { func (*AddAllowRules) ProtoMessage() {} func (x *AddAllowRules) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[112] + mi := &file_openshell_proto_msgTypes[114] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8096,7 +8334,7 @@ func (x *AddAllowRules) ProtoReflect() protoreflect.Message { // Deprecated: Use AddAllowRules.ProtoReflect.Descriptor instead. func (*AddAllowRules) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{112} + return file_openshell_proto_rawDescGZIP(), []int{114} } func (x *AddAllowRules) GetHost() string { @@ -8130,7 +8368,7 @@ type RemoveNetworkBinary struct { func (x *RemoveNetworkBinary) Reset() { *x = RemoveNetworkBinary{} - mi := &file_openshell_proto_msgTypes[113] + mi := &file_openshell_proto_msgTypes[115] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8142,7 +8380,7 @@ func (x *RemoveNetworkBinary) String() string { func (*RemoveNetworkBinary) ProtoMessage() {} func (x *RemoveNetworkBinary) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[113] + mi := &file_openshell_proto_msgTypes[115] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8155,7 +8393,7 @@ func (x *RemoveNetworkBinary) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveNetworkBinary.ProtoReflect.Descriptor instead. func (*RemoveNetworkBinary) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{113} + return file_openshell_proto_rawDescGZIP(), []int{115} } func (x *RemoveNetworkBinary) GetRuleName() string { @@ -8191,7 +8429,7 @@ type UpdateConfigResponse struct { func (x *UpdateConfigResponse) Reset() { *x = UpdateConfigResponse{} - mi := &file_openshell_proto_msgTypes[114] + mi := &file_openshell_proto_msgTypes[116] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8203,7 +8441,7 @@ func (x *UpdateConfigResponse) String() string { func (*UpdateConfigResponse) ProtoMessage() {} func (x *UpdateConfigResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[114] + mi := &file_openshell_proto_msgTypes[116] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8216,7 +8454,7 @@ func (x *UpdateConfigResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateConfigResponse.ProtoReflect.Descriptor instead. func (*UpdateConfigResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{114} + return file_openshell_proto_rawDescGZIP(), []int{116} } func (x *UpdateConfigResponse) GetVersion() uint32 { @@ -8271,7 +8509,7 @@ type GetSandboxPolicyStatusRequest struct { func (x *GetSandboxPolicyStatusRequest) Reset() { *x = GetSandboxPolicyStatusRequest{} - mi := &file_openshell_proto_msgTypes[115] + mi := &file_openshell_proto_msgTypes[117] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8283,7 +8521,7 @@ func (x *GetSandboxPolicyStatusRequest) String() string { func (*GetSandboxPolicyStatusRequest) ProtoMessage() {} func (x *GetSandboxPolicyStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[115] + mi := &file_openshell_proto_msgTypes[117] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8296,7 +8534,7 @@ func (x *GetSandboxPolicyStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxPolicyStatusRequest.ProtoReflect.Descriptor instead. func (*GetSandboxPolicyStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{115} + return file_openshell_proto_rawDescGZIP(), []int{117} } func (x *GetSandboxPolicyStatusRequest) GetName() string { @@ -8340,7 +8578,7 @@ type GetSandboxPolicyStatusResponse struct { func (x *GetSandboxPolicyStatusResponse) Reset() { *x = GetSandboxPolicyStatusResponse{} - mi := &file_openshell_proto_msgTypes[116] + mi := &file_openshell_proto_msgTypes[118] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8352,7 +8590,7 @@ func (x *GetSandboxPolicyStatusResponse) String() string { func (*GetSandboxPolicyStatusResponse) ProtoMessage() {} func (x *GetSandboxPolicyStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[116] + mi := &file_openshell_proto_msgTypes[118] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8365,7 +8603,7 @@ func (x *GetSandboxPolicyStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxPolicyStatusResponse.ProtoReflect.Descriptor instead. func (*GetSandboxPolicyStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{116} + return file_openshell_proto_rawDescGZIP(), []int{118} } func (x *GetSandboxPolicyStatusResponse) GetRevision() *SandboxPolicyRevision { @@ -8399,7 +8637,7 @@ type ListSandboxPoliciesRequest struct { func (x *ListSandboxPoliciesRequest) Reset() { *x = ListSandboxPoliciesRequest{} - mi := &file_openshell_proto_msgTypes[117] + mi := &file_openshell_proto_msgTypes[119] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8411,7 +8649,7 @@ func (x *ListSandboxPoliciesRequest) String() string { func (*ListSandboxPoliciesRequest) ProtoMessage() {} func (x *ListSandboxPoliciesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[117] + mi := &file_openshell_proto_msgTypes[119] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8424,7 +8662,7 @@ func (x *ListSandboxPoliciesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxPoliciesRequest.ProtoReflect.Descriptor instead. func (*ListSandboxPoliciesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{117} + return file_openshell_proto_rawDescGZIP(), []int{119} } func (x *ListSandboxPoliciesRequest) GetName() string { @@ -8472,7 +8710,7 @@ type ListSandboxPoliciesResponse struct { func (x *ListSandboxPoliciesResponse) Reset() { *x = ListSandboxPoliciesResponse{} - mi := &file_openshell_proto_msgTypes[118] + mi := &file_openshell_proto_msgTypes[120] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8484,7 +8722,7 @@ func (x *ListSandboxPoliciesResponse) String() string { func (*ListSandboxPoliciesResponse) ProtoMessage() {} func (x *ListSandboxPoliciesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[118] + mi := &file_openshell_proto_msgTypes[120] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8497,7 +8735,7 @@ func (x *ListSandboxPoliciesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxPoliciesResponse.ProtoReflect.Descriptor instead. func (*ListSandboxPoliciesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{118} + return file_openshell_proto_rawDescGZIP(), []int{120} } func (x *ListSandboxPoliciesResponse) GetRevisions() []*SandboxPolicyRevision { @@ -8524,7 +8762,7 @@ type ReportPolicyStatusRequest struct { func (x *ReportPolicyStatusRequest) Reset() { *x = ReportPolicyStatusRequest{} - mi := &file_openshell_proto_msgTypes[119] + mi := &file_openshell_proto_msgTypes[121] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8536,7 +8774,7 @@ func (x *ReportPolicyStatusRequest) String() string { func (*ReportPolicyStatusRequest) ProtoMessage() {} func (x *ReportPolicyStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[119] + mi := &file_openshell_proto_msgTypes[121] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8549,7 +8787,7 @@ func (x *ReportPolicyStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportPolicyStatusRequest.ProtoReflect.Descriptor instead. func (*ReportPolicyStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{119} + return file_openshell_proto_rawDescGZIP(), []int{121} } func (x *ReportPolicyStatusRequest) GetSandboxId() string { @@ -8589,7 +8827,7 @@ type ReportPolicyStatusResponse struct { func (x *ReportPolicyStatusResponse) Reset() { *x = ReportPolicyStatusResponse{} - mi := &file_openshell_proto_msgTypes[120] + mi := &file_openshell_proto_msgTypes[122] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8601,7 +8839,7 @@ func (x *ReportPolicyStatusResponse) String() string { func (*ReportPolicyStatusResponse) ProtoMessage() {} func (x *ReportPolicyStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[120] + mi := &file_openshell_proto_msgTypes[122] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8614,7 +8852,7 @@ func (x *ReportPolicyStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportPolicyStatusResponse.ProtoReflect.Descriptor instead. func (*ReportPolicyStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{120} + return file_openshell_proto_rawDescGZIP(), []int{122} } // A versioned policy revision with metadata. @@ -8642,7 +8880,7 @@ type SandboxPolicyRevision struct { func (x *SandboxPolicyRevision) Reset() { *x = SandboxPolicyRevision{} - mi := &file_openshell_proto_msgTypes[121] + mi := &file_openshell_proto_msgTypes[123] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8654,7 +8892,7 @@ func (x *SandboxPolicyRevision) String() string { func (*SandboxPolicyRevision) ProtoMessage() {} func (x *SandboxPolicyRevision) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[121] + mi := &file_openshell_proto_msgTypes[123] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8667,7 +8905,7 @@ func (x *SandboxPolicyRevision) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxPolicyRevision.ProtoReflect.Descriptor instead. func (*SandboxPolicyRevision) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{121} + return file_openshell_proto_rawDescGZIP(), []int{123} } func (x *SandboxPolicyRevision) GetVersion() uint32 { @@ -8747,7 +8985,7 @@ type GetSandboxLogsRequest struct { func (x *GetSandboxLogsRequest) Reset() { *x = GetSandboxLogsRequest{} - mi := &file_openshell_proto_msgTypes[122] + mi := &file_openshell_proto_msgTypes[124] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8759,7 +8997,7 @@ func (x *GetSandboxLogsRequest) String() string { func (*GetSandboxLogsRequest) ProtoMessage() {} func (x *GetSandboxLogsRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[122] + mi := &file_openshell_proto_msgTypes[124] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8772,7 +9010,7 @@ func (x *GetSandboxLogsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxLogsRequest.ProtoReflect.Descriptor instead. func (*GetSandboxLogsRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{122} + return file_openshell_proto_rawDescGZIP(), []int{124} } func (x *GetSandboxLogsRequest) GetSandboxId() string { @@ -8830,7 +9068,7 @@ type PushSandboxLogsRequest struct { func (x *PushSandboxLogsRequest) Reset() { *x = PushSandboxLogsRequest{} - mi := &file_openshell_proto_msgTypes[123] + mi := &file_openshell_proto_msgTypes[125] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8842,7 +9080,7 @@ func (x *PushSandboxLogsRequest) String() string { func (*PushSandboxLogsRequest) ProtoMessage() {} func (x *PushSandboxLogsRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[123] + mi := &file_openshell_proto_msgTypes[125] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8855,7 +9093,7 @@ func (x *PushSandboxLogsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use PushSandboxLogsRequest.ProtoReflect.Descriptor instead. func (*PushSandboxLogsRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{123} + return file_openshell_proto_rawDescGZIP(), []int{125} } func (x *PushSandboxLogsRequest) GetSandboxId() string { @@ -8881,7 +9119,7 @@ type PushSandboxLogsResponse struct { func (x *PushSandboxLogsResponse) Reset() { *x = PushSandboxLogsResponse{} - mi := &file_openshell_proto_msgTypes[124] + mi := &file_openshell_proto_msgTypes[126] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8893,7 +9131,7 @@ func (x *PushSandboxLogsResponse) String() string { func (*PushSandboxLogsResponse) ProtoMessage() {} func (x *PushSandboxLogsResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[124] + mi := &file_openshell_proto_msgTypes[126] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8906,7 +9144,7 @@ func (x *PushSandboxLogsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use PushSandboxLogsResponse.ProtoReflect.Descriptor instead. func (*PushSandboxLogsResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{124} + return file_openshell_proto_rawDescGZIP(), []int{126} } // Get sandbox logs response. @@ -8922,7 +9160,7 @@ type GetSandboxLogsResponse struct { func (x *GetSandboxLogsResponse) Reset() { *x = GetSandboxLogsResponse{} - mi := &file_openshell_proto_msgTypes[125] + mi := &file_openshell_proto_msgTypes[127] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8934,7 +9172,7 @@ func (x *GetSandboxLogsResponse) String() string { func (*GetSandboxLogsResponse) ProtoMessage() {} func (x *GetSandboxLogsResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[125] + mi := &file_openshell_proto_msgTypes[127] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8947,7 +9185,7 @@ func (x *GetSandboxLogsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxLogsResponse.ProtoReflect.Descriptor instead. func (*GetSandboxLogsResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{125} + return file_openshell_proto_rawDescGZIP(), []int{127} } func (x *GetSandboxLogsResponse) GetLogs() []*SandboxLogLine { @@ -8973,6 +9211,7 @@ type SupervisorMessage struct { // *SupervisorMessage_Heartbeat // *SupervisorMessage_RelayOpenResult // *SupervisorMessage_RelayClose + // *SupervisorMessage_MainProcessExit Payload isSupervisorMessage_Payload `protobuf_oneof:"payload"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache @@ -8980,7 +9219,7 @@ type SupervisorMessage struct { func (x *SupervisorMessage) Reset() { *x = SupervisorMessage{} - mi := &file_openshell_proto_msgTypes[126] + mi := &file_openshell_proto_msgTypes[128] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8992,7 +9231,7 @@ func (x *SupervisorMessage) String() string { func (*SupervisorMessage) ProtoMessage() {} func (x *SupervisorMessage) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[126] + mi := &file_openshell_proto_msgTypes[128] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9005,7 +9244,7 @@ func (x *SupervisorMessage) ProtoReflect() protoreflect.Message { // Deprecated: Use SupervisorMessage.ProtoReflect.Descriptor instead. func (*SupervisorMessage) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{126} + return file_openshell_proto_rawDescGZIP(), []int{128} } func (x *SupervisorMessage) GetPayload() isSupervisorMessage_Payload { @@ -9051,6 +9290,15 @@ func (x *SupervisorMessage) GetRelayClose() *RelayClose { return nil } +func (x *SupervisorMessage) GetMainProcessExit() *MainProcessExit { + if x != nil { + if x, ok := x.Payload.(*SupervisorMessage_MainProcessExit); ok { + return x.MainProcessExit + } + } + return nil +} + type isSupervisorMessage_Payload interface { isSupervisorMessage_Payload() } @@ -9071,6 +9319,10 @@ type SupervisorMessage_RelayClose struct { RelayClose *RelayClose `protobuf:"bytes,4,opt,name=relay_close,json=relayClose,proto3,oneof"` } +type SupervisorMessage_MainProcessExit struct { + MainProcessExit *MainProcessExit `protobuf:"bytes,5,opt,name=main_process_exit,json=mainProcessExit,proto3,oneof"` +} + func (*SupervisorMessage_Hello) isSupervisorMessage_Payload() {} func (*SupervisorMessage_Heartbeat) isSupervisorMessage_Payload() {} @@ -9079,6 +9331,8 @@ func (*SupervisorMessage_RelayOpenResult) isSupervisorMessage_Payload() {} func (*SupervisorMessage_RelayClose) isSupervisorMessage_Payload() {} +func (*SupervisorMessage_MainProcessExit) isSupervisorMessage_Payload() {} + // Envelope for gateway-to-supervisor messages on the ConnectSupervisor stream. type GatewayMessage struct { state protoimpl.MessageState `protogen:"open.v1"` @@ -9089,6 +9343,7 @@ type GatewayMessage struct { // *GatewayMessage_Heartbeat // *GatewayMessage_RelayOpen // *GatewayMessage_RelayClose + // *GatewayMessage_MainProcessExitAck Payload isGatewayMessage_Payload `protobuf_oneof:"payload"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache @@ -9096,7 +9351,7 @@ type GatewayMessage struct { func (x *GatewayMessage) Reset() { *x = GatewayMessage{} - mi := &file_openshell_proto_msgTypes[127] + mi := &file_openshell_proto_msgTypes[129] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9108,7 +9363,7 @@ func (x *GatewayMessage) String() string { func (*GatewayMessage) ProtoMessage() {} func (x *GatewayMessage) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[127] + mi := &file_openshell_proto_msgTypes[129] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9121,7 +9376,7 @@ func (x *GatewayMessage) ProtoReflect() protoreflect.Message { // Deprecated: Use GatewayMessage.ProtoReflect.Descriptor instead. func (*GatewayMessage) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{127} + return file_openshell_proto_rawDescGZIP(), []int{129} } func (x *GatewayMessage) GetPayload() isGatewayMessage_Payload { @@ -9176,6 +9431,15 @@ func (x *GatewayMessage) GetRelayClose() *RelayClose { return nil } +func (x *GatewayMessage) GetMainProcessExitAck() *MainProcessExitAck { + if x != nil { + if x, ok := x.Payload.(*GatewayMessage_MainProcessExitAck); ok { + return x.MainProcessExitAck + } + } + return nil +} + type isGatewayMessage_Payload interface { isGatewayMessage_Payload() } @@ -9200,6 +9464,10 @@ type GatewayMessage_RelayClose struct { RelayClose *RelayClose `protobuf:"bytes,5,opt,name=relay_close,json=relayClose,proto3,oneof"` } +type GatewayMessage_MainProcessExitAck struct { + MainProcessExitAck *MainProcessExitAck `protobuf:"bytes,6,opt,name=main_process_exit_ack,json=mainProcessExitAck,proto3,oneof"` +} + func (*GatewayMessage_SessionAccepted) isGatewayMessage_Payload() {} func (*GatewayMessage_SessionRejected) isGatewayMessage_Payload() {} @@ -9210,20 +9478,25 @@ func (*GatewayMessage_RelayOpen) isGatewayMessage_Payload() {} func (*GatewayMessage_RelayClose) isGatewayMessage_Payload() {} +func (*GatewayMessage_MainProcessExitAck) isGatewayMessage_Payload() {} + // Supervisor identifies itself and the sandbox it manages. type SupervisorHello struct { state protoimpl.MessageState `protogen:"open.v1"` // Sandbox ID this supervisor manages. SandboxId string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` // Supervisor instance ID (e.g. boot id or process epoch). - InstanceId string `protobuf:"bytes,2,opt,name=instance_id,json=instanceId,proto3" json:"instance_id,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + InstanceId string `protobuf:"bytes,2,opt,name=instance_id,json=instanceId,proto3" json:"instance_id,omitempty"` + // Short-lived terminal-result sessions authenticate an existing generation + // but must not replace the active relay session or advertise readiness. + ExitReportOnly bool `protobuf:"varint,3,opt,name=exit_report_only,json=exitReportOnly,proto3" json:"exit_report_only,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *SupervisorHello) Reset() { *x = SupervisorHello{} - mi := &file_openshell_proto_msgTypes[128] + mi := &file_openshell_proto_msgTypes[130] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9235,7 +9508,7 @@ func (x *SupervisorHello) String() string { func (*SupervisorHello) ProtoMessage() {} func (x *SupervisorHello) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[128] + mi := &file_openshell_proto_msgTypes[130] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9248,7 +9521,7 @@ func (x *SupervisorHello) ProtoReflect() protoreflect.Message { // Deprecated: Use SupervisorHello.ProtoReflect.Descriptor instead. func (*SupervisorHello) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{128} + return file_openshell_proto_rawDescGZIP(), []int{130} } func (x *SupervisorHello) GetSandboxId() string { @@ -9265,6 +9538,13 @@ func (x *SupervisorHello) GetInstanceId() string { return "" } +func (x *SupervisorHello) GetExitReportOnly() bool { + if x != nil { + return x.ExitReportOnly + } + return false +} + // Gateway accepts the supervisor session. type SessionAccepted struct { state protoimpl.MessageState `protogen:"open.v1"` @@ -9278,7 +9558,7 @@ type SessionAccepted struct { func (x *SessionAccepted) Reset() { *x = SessionAccepted{} - mi := &file_openshell_proto_msgTypes[129] + mi := &file_openshell_proto_msgTypes[131] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9290,7 +9570,7 @@ func (x *SessionAccepted) String() string { func (*SessionAccepted) ProtoMessage() {} func (x *SessionAccepted) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[129] + mi := &file_openshell_proto_msgTypes[131] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9303,7 +9583,7 @@ func (x *SessionAccepted) ProtoReflect() protoreflect.Message { // Deprecated: Use SessionAccepted.ProtoReflect.Descriptor instead. func (*SessionAccepted) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{129} + return file_openshell_proto_rawDescGZIP(), []int{131} } func (x *SessionAccepted) GetSessionId() string { @@ -9331,7 +9611,7 @@ type SessionRejected struct { func (x *SessionRejected) Reset() { *x = SessionRejected{} - mi := &file_openshell_proto_msgTypes[130] + mi := &file_openshell_proto_msgTypes[132] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9343,7 +9623,7 @@ func (x *SessionRejected) String() string { func (*SessionRejected) ProtoMessage() {} func (x *SessionRejected) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[130] + mi := &file_openshell_proto_msgTypes[132] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9356,7 +9636,7 @@ func (x *SessionRejected) ProtoReflect() protoreflect.Message { // Deprecated: Use SessionRejected.ProtoReflect.Descriptor instead. func (*SessionRejected) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{130} + return file_openshell_proto_rawDescGZIP(), []int{132} } func (x *SessionRejected) GetReason() string { @@ -9375,7 +9655,7 @@ type SupervisorHeartbeat struct { func (x *SupervisorHeartbeat) Reset() { *x = SupervisorHeartbeat{} - mi := &file_openshell_proto_msgTypes[131] + mi := &file_openshell_proto_msgTypes[133] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9387,7 +9667,7 @@ func (x *SupervisorHeartbeat) String() string { func (*SupervisorHeartbeat) ProtoMessage() {} func (x *SupervisorHeartbeat) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[131] + mi := &file_openshell_proto_msgTypes[133] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9400,7 +9680,7 @@ func (x *SupervisorHeartbeat) ProtoReflect() protoreflect.Message { // Deprecated: Use SupervisorHeartbeat.ProtoReflect.Descriptor instead. func (*SupervisorHeartbeat) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{131} + return file_openshell_proto_rawDescGZIP(), []int{133} } // Gateway heartbeat. @@ -9412,7 +9692,7 @@ type GatewayHeartbeat struct { func (x *GatewayHeartbeat) Reset() { *x = GatewayHeartbeat{} - mi := &file_openshell_proto_msgTypes[132] + mi := &file_openshell_proto_msgTypes[134] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9424,7 +9704,7 @@ func (x *GatewayHeartbeat) String() string { func (*GatewayHeartbeat) ProtoMessage() {} func (x *GatewayHeartbeat) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[132] + mi := &file_openshell_proto_msgTypes[134] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9437,7 +9717,130 @@ func (x *GatewayHeartbeat) ProtoReflect() protoreflect.Message { // Deprecated: Use GatewayHeartbeat.ProtoReflect.Descriptor instead. func (*GatewayHeartbeat) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{132} + return file_openshell_proto_rawDescGZIP(), []int{134} +} + +// Terminal result reported before the supervisor shuts down. A missing exit +// code with a present signal represents signal termination. +type MainProcessExit struct { + state protoimpl.MessageState `protogen:"open.v1"` + Generation string `protobuf:"bytes,1,opt,name=generation,proto3" json:"generation,omitempty"` + ExitCode *int32 `protobuf:"varint,2,opt,name=exit_code,json=exitCode,proto3,oneof" json:"exit_code,omitempty"` + Signal *int32 `protobuf:"varint,3,opt,name=signal,proto3,oneof" json:"signal,omitempty"` + StartedAtMs int64 `protobuf:"varint,4,opt,name=started_at_ms,json=startedAtMs,proto3" json:"started_at_ms,omitempty"` + FinishedAtMs int64 `protobuf:"varint,5,opt,name=finished_at_ms,json=finishedAtMs,proto3" json:"finished_at_ms,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *MainProcessExit) Reset() { + *x = MainProcessExit{} + mi := &file_openshell_proto_msgTypes[135] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *MainProcessExit) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MainProcessExit) ProtoMessage() {} + +func (x *MainProcessExit) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[135] + 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 MainProcessExit.ProtoReflect.Descriptor instead. +func (*MainProcessExit) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{135} +} + +func (x *MainProcessExit) GetGeneration() string { + if x != nil { + return x.Generation + } + return "" +} + +func (x *MainProcessExit) GetExitCode() int32 { + if x != nil && x.ExitCode != nil { + return *x.ExitCode + } + return 0 +} + +func (x *MainProcessExit) GetSignal() int32 { + if x != nil && x.Signal != nil { + return *x.Signal + } + return 0 +} + +func (x *MainProcessExit) GetStartedAtMs() int64 { + if x != nil { + return x.StartedAtMs + } + return 0 +} + +func (x *MainProcessExit) GetFinishedAtMs() int64 { + if x != nil { + return x.FinishedAtMs + } + return 0 +} + +// Gateway acknowledgement that the terminal result has been durably handled. +type MainProcessExitAck struct { + state protoimpl.MessageState `protogen:"open.v1"` + Generation string `protobuf:"bytes,1,opt,name=generation,proto3" json:"generation,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *MainProcessExitAck) Reset() { + *x = MainProcessExitAck{} + mi := &file_openshell_proto_msgTypes[136] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *MainProcessExitAck) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MainProcessExitAck) ProtoMessage() {} + +func (x *MainProcessExitAck) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[136] + 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 MainProcessExitAck.ProtoReflect.Descriptor instead. +func (*MainProcessExitAck) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{136} +} + +func (x *MainProcessExitAck) GetGeneration() string { + if x != nil { + return x.Generation + } + return "" } // Gateway requests the supervisor to open a relay channel. @@ -9466,7 +9869,7 @@ type RelayOpen struct { func (x *RelayOpen) Reset() { *x = RelayOpen{} - mi := &file_openshell_proto_msgTypes[133] + mi := &file_openshell_proto_msgTypes[137] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9478,7 +9881,7 @@ func (x *RelayOpen) String() string { func (*RelayOpen) ProtoMessage() {} func (x *RelayOpen) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[133] + mi := &file_openshell_proto_msgTypes[137] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9491,7 +9894,7 @@ func (x *RelayOpen) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayOpen.ProtoReflect.Descriptor instead. func (*RelayOpen) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{133} + return file_openshell_proto_rawDescGZIP(), []int{137} } func (x *RelayOpen) GetChannelId() string { @@ -9558,7 +9961,7 @@ type SshRelayTarget struct { func (x *SshRelayTarget) Reset() { *x = SshRelayTarget{} - mi := &file_openshell_proto_msgTypes[134] + mi := &file_openshell_proto_msgTypes[138] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9570,7 +9973,7 @@ func (x *SshRelayTarget) String() string { func (*SshRelayTarget) ProtoMessage() {} func (x *SshRelayTarget) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[134] + mi := &file_openshell_proto_msgTypes[138] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9583,7 +9986,7 @@ func (x *SshRelayTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use SshRelayTarget.ProtoReflect.Descriptor instead. func (*SshRelayTarget) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{134} + return file_openshell_proto_rawDescGZIP(), []int{138} } // TCP target dialed by the supervisor from inside the sandbox. @@ -9599,7 +10002,7 @@ type TcpRelayTarget struct { func (x *TcpRelayTarget) Reset() { *x = TcpRelayTarget{} - mi := &file_openshell_proto_msgTypes[135] + mi := &file_openshell_proto_msgTypes[139] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9611,7 +10014,7 @@ func (x *TcpRelayTarget) String() string { func (*TcpRelayTarget) ProtoMessage() {} func (x *TcpRelayTarget) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[135] + mi := &file_openshell_proto_msgTypes[139] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9624,7 +10027,7 @@ func (x *TcpRelayTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use TcpRelayTarget.ProtoReflect.Descriptor instead. func (*TcpRelayTarget) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{135} + return file_openshell_proto_rawDescGZIP(), []int{139} } func (x *TcpRelayTarget) GetHost() string { @@ -9652,7 +10055,7 @@ type RelayInit struct { func (x *RelayInit) Reset() { *x = RelayInit{} - mi := &file_openshell_proto_msgTypes[136] + mi := &file_openshell_proto_msgTypes[140] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9664,7 +10067,7 @@ func (x *RelayInit) String() string { func (*RelayInit) ProtoMessage() {} func (x *RelayInit) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[136] + mi := &file_openshell_proto_msgTypes[140] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9677,7 +10080,7 @@ func (x *RelayInit) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayInit.ProtoReflect.Descriptor instead. func (*RelayInit) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{136} + return file_openshell_proto_rawDescGZIP(), []int{140} } func (x *RelayInit) GetChannelId() string { @@ -9704,7 +10107,7 @@ type RelayFrame struct { func (x *RelayFrame) Reset() { *x = RelayFrame{} - mi := &file_openshell_proto_msgTypes[137] + mi := &file_openshell_proto_msgTypes[141] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9716,7 +10119,7 @@ func (x *RelayFrame) String() string { func (*RelayFrame) ProtoMessage() {} func (x *RelayFrame) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[137] + mi := &file_openshell_proto_msgTypes[141] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9729,7 +10132,7 @@ func (x *RelayFrame) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayFrame.ProtoReflect.Descriptor instead. func (*RelayFrame) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{137} + return file_openshell_proto_rawDescGZIP(), []int{141} } func (x *RelayFrame) GetPayload() isRelayFrame_Payload { @@ -9788,7 +10191,7 @@ type RelayOpenResult struct { func (x *RelayOpenResult) Reset() { *x = RelayOpenResult{} - mi := &file_openshell_proto_msgTypes[138] + mi := &file_openshell_proto_msgTypes[142] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9800,7 +10203,7 @@ func (x *RelayOpenResult) String() string { func (*RelayOpenResult) ProtoMessage() {} func (x *RelayOpenResult) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[138] + mi := &file_openshell_proto_msgTypes[142] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9813,7 +10216,7 @@ func (x *RelayOpenResult) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayOpenResult.ProtoReflect.Descriptor instead. func (*RelayOpenResult) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{138} + return file_openshell_proto_rawDescGZIP(), []int{142} } func (x *RelayOpenResult) GetChannelId() string { @@ -9850,7 +10253,7 @@ type RelayClose struct { func (x *RelayClose) Reset() { *x = RelayClose{} - mi := &file_openshell_proto_msgTypes[139] + mi := &file_openshell_proto_msgTypes[143] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9862,7 +10265,7 @@ func (x *RelayClose) String() string { func (*RelayClose) ProtoMessage() {} func (x *RelayClose) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[139] + mi := &file_openshell_proto_msgTypes[143] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9875,7 +10278,7 @@ func (x *RelayClose) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayClose.ProtoReflect.Descriptor instead. func (*RelayClose) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{139} + return file_openshell_proto_rawDescGZIP(), []int{143} } func (x *RelayClose) GetChannelId() string { @@ -9909,7 +10312,7 @@ type L7RequestSample struct { func (x *L7RequestSample) Reset() { *x = L7RequestSample{} - mi := &file_openshell_proto_msgTypes[140] + mi := &file_openshell_proto_msgTypes[144] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9921,7 +10324,7 @@ func (x *L7RequestSample) String() string { func (*L7RequestSample) ProtoMessage() {} func (x *L7RequestSample) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[140] + mi := &file_openshell_proto_msgTypes[144] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9934,7 +10337,7 @@ func (x *L7RequestSample) ProtoReflect() protoreflect.Message { // Deprecated: Use L7RequestSample.ProtoReflect.Descriptor instead. func (*L7RequestSample) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{140} + return file_openshell_proto_rawDescGZIP(), []int{144} } func (x *L7RequestSample) GetMethod() string { @@ -10008,7 +10411,7 @@ type DenialSummary struct { func (x *DenialSummary) Reset() { *x = DenialSummary{} - mi := &file_openshell_proto_msgTypes[141] + mi := &file_openshell_proto_msgTypes[145] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10020,7 +10423,7 @@ func (x *DenialSummary) String() string { func (*DenialSummary) ProtoMessage() {} func (x *DenialSummary) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[141] + mi := &file_openshell_proto_msgTypes[145] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10033,7 +10436,7 @@ func (x *DenialSummary) ProtoReflect() protoreflect.Message { // Deprecated: Use DenialSummary.ProtoReflect.Descriptor instead. func (*DenialSummary) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{141} + return file_openshell_proto_rawDescGZIP(), []int{145} } func (x *DenialSummary) GetSandboxId() string { @@ -10168,7 +10571,7 @@ type DenialGroupCount struct { func (x *DenialGroupCount) Reset() { *x = DenialGroupCount{} - mi := &file_openshell_proto_msgTypes[142] + mi := &file_openshell_proto_msgTypes[146] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10180,7 +10583,7 @@ func (x *DenialGroupCount) String() string { func (*DenialGroupCount) ProtoMessage() {} func (x *DenialGroupCount) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[142] + mi := &file_openshell_proto_msgTypes[146] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10193,7 +10596,7 @@ func (x *DenialGroupCount) ProtoReflect() protoreflect.Message { // Deprecated: Use DenialGroupCount.ProtoReflect.Descriptor instead. func (*DenialGroupCount) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{142} + return file_openshell_proto_rawDescGZIP(), []int{146} } func (x *DenialGroupCount) GetDenyGroup() string { @@ -10226,7 +10629,7 @@ type NetworkActivitySummary struct { func (x *NetworkActivitySummary) Reset() { *x = NetworkActivitySummary{} - mi := &file_openshell_proto_msgTypes[143] + mi := &file_openshell_proto_msgTypes[147] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10238,7 +10641,7 @@ func (x *NetworkActivitySummary) String() string { func (*NetworkActivitySummary) ProtoMessage() {} func (x *NetworkActivitySummary) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[143] + mi := &file_openshell_proto_msgTypes[147] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10251,7 +10654,7 @@ func (x *NetworkActivitySummary) ProtoReflect() protoreflect.Message { // Deprecated: Use NetworkActivitySummary.ProtoReflect.Descriptor instead. func (*NetworkActivitySummary) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{143} + return file_openshell_proto_rawDescGZIP(), []int{147} } func (x *NetworkActivitySummary) GetNetworkActivityCount() uint32 { @@ -10325,7 +10728,7 @@ type PolicyChunk struct { func (x *PolicyChunk) Reset() { *x = PolicyChunk{} - mi := &file_openshell_proto_msgTypes[144] + mi := &file_openshell_proto_msgTypes[148] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10337,7 +10740,7 @@ func (x *PolicyChunk) String() string { func (*PolicyChunk) ProtoMessage() {} func (x *PolicyChunk) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[144] + mi := &file_openshell_proto_msgTypes[148] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10350,7 +10753,7 @@ func (x *PolicyChunk) ProtoReflect() protoreflect.Message { // Deprecated: Use PolicyChunk.ProtoReflect.Descriptor instead. func (*PolicyChunk) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{144} + return file_openshell_proto_rawDescGZIP(), []int{148} } func (x *PolicyChunk) GetId() string { @@ -10496,7 +10899,7 @@ type DraftPolicyUpdate struct { func (x *DraftPolicyUpdate) Reset() { *x = DraftPolicyUpdate{} - mi := &file_openshell_proto_msgTypes[145] + mi := &file_openshell_proto_msgTypes[149] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10508,7 +10911,7 @@ func (x *DraftPolicyUpdate) String() string { func (*DraftPolicyUpdate) ProtoMessage() {} func (x *DraftPolicyUpdate) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[145] + mi := &file_openshell_proto_msgTypes[149] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10521,7 +10924,7 @@ func (x *DraftPolicyUpdate) ProtoReflect() protoreflect.Message { // Deprecated: Use DraftPolicyUpdate.ProtoReflect.Descriptor instead. func (*DraftPolicyUpdate) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{145} + return file_openshell_proto_rawDescGZIP(), []int{149} } func (x *DraftPolicyUpdate) GetDraftVersion() uint64 { @@ -10579,7 +10982,7 @@ type SubmitPolicyAnalysisRequest struct { func (x *SubmitPolicyAnalysisRequest) Reset() { *x = SubmitPolicyAnalysisRequest{} - mi := &file_openshell_proto_msgTypes[146] + mi := &file_openshell_proto_msgTypes[150] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10591,7 +10994,7 @@ func (x *SubmitPolicyAnalysisRequest) String() string { func (*SubmitPolicyAnalysisRequest) ProtoMessage() {} func (x *SubmitPolicyAnalysisRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[146] + mi := &file_openshell_proto_msgTypes[150] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10604,7 +11007,7 @@ func (x *SubmitPolicyAnalysisRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SubmitPolicyAnalysisRequest.ProtoReflect.Descriptor instead. func (*SubmitPolicyAnalysisRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{146} + return file_openshell_proto_rawDescGZIP(), []int{150} } func (x *SubmitPolicyAnalysisRequest) GetSummaries() []*DenialSummary { @@ -10667,7 +11070,7 @@ type SubmitPolicyAnalysisResponse struct { func (x *SubmitPolicyAnalysisResponse) Reset() { *x = SubmitPolicyAnalysisResponse{} - mi := &file_openshell_proto_msgTypes[147] + mi := &file_openshell_proto_msgTypes[151] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10679,7 +11082,7 @@ func (x *SubmitPolicyAnalysisResponse) String() string { func (*SubmitPolicyAnalysisResponse) ProtoMessage() {} func (x *SubmitPolicyAnalysisResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[147] + mi := &file_openshell_proto_msgTypes[151] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10692,7 +11095,7 @@ func (x *SubmitPolicyAnalysisResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SubmitPolicyAnalysisResponse.ProtoReflect.Descriptor instead. func (*SubmitPolicyAnalysisResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{147} + return file_openshell_proto_rawDescGZIP(), []int{151} } func (x *SubmitPolicyAnalysisResponse) GetAcceptedChunks() uint32 { @@ -10738,7 +11141,7 @@ type GetDraftPolicyRequest struct { func (x *GetDraftPolicyRequest) Reset() { *x = GetDraftPolicyRequest{} - mi := &file_openshell_proto_msgTypes[148] + mi := &file_openshell_proto_msgTypes[152] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10750,7 +11153,7 @@ func (x *GetDraftPolicyRequest) String() string { func (*GetDraftPolicyRequest) ProtoMessage() {} func (x *GetDraftPolicyRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[148] + mi := &file_openshell_proto_msgTypes[152] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10763,7 +11166,7 @@ func (x *GetDraftPolicyRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftPolicyRequest.ProtoReflect.Descriptor instead. func (*GetDraftPolicyRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{148} + return file_openshell_proto_rawDescGZIP(), []int{152} } func (x *GetDraftPolicyRequest) GetName() string { @@ -10803,7 +11206,7 @@ type GetDraftPolicyResponse struct { func (x *GetDraftPolicyResponse) Reset() { *x = GetDraftPolicyResponse{} - mi := &file_openshell_proto_msgTypes[149] + mi := &file_openshell_proto_msgTypes[153] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10815,7 +11218,7 @@ func (x *GetDraftPolicyResponse) String() string { func (*GetDraftPolicyResponse) ProtoMessage() {} func (x *GetDraftPolicyResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[149] + mi := &file_openshell_proto_msgTypes[153] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10828,7 +11231,7 @@ func (x *GetDraftPolicyResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftPolicyResponse.ProtoReflect.Descriptor instead. func (*GetDraftPolicyResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{149} + return file_openshell_proto_rawDescGZIP(), []int{153} } func (x *GetDraftPolicyResponse) GetChunks() []*PolicyChunk { @@ -10874,7 +11277,7 @@ type ApproveDraftChunkRequest struct { func (x *ApproveDraftChunkRequest) Reset() { *x = ApproveDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[150] + mi := &file_openshell_proto_msgTypes[154] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10886,7 +11289,7 @@ func (x *ApproveDraftChunkRequest) String() string { func (*ApproveDraftChunkRequest) ProtoMessage() {} func (x *ApproveDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[150] + mi := &file_openshell_proto_msgTypes[154] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10899,7 +11302,7 @@ func (x *ApproveDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveDraftChunkRequest.ProtoReflect.Descriptor instead. func (*ApproveDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{150} + return file_openshell_proto_rawDescGZIP(), []int{154} } func (x *ApproveDraftChunkRequest) GetName() string { @@ -10935,7 +11338,7 @@ type ApproveDraftChunkResponse struct { func (x *ApproveDraftChunkResponse) Reset() { *x = ApproveDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[151] + mi := &file_openshell_proto_msgTypes[155] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10947,7 +11350,7 @@ func (x *ApproveDraftChunkResponse) String() string { func (*ApproveDraftChunkResponse) ProtoMessage() {} func (x *ApproveDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[151] + mi := &file_openshell_proto_msgTypes[155] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10960,7 +11363,7 @@ func (x *ApproveDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveDraftChunkResponse.ProtoReflect.Descriptor instead. func (*ApproveDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{151} + return file_openshell_proto_rawDescGZIP(), []int{155} } func (x *ApproveDraftChunkResponse) GetPolicyVersion() uint32 { @@ -10994,7 +11397,7 @@ type RejectDraftChunkRequest struct { func (x *RejectDraftChunkRequest) Reset() { *x = RejectDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[152] + mi := &file_openshell_proto_msgTypes[156] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11006,7 +11409,7 @@ func (x *RejectDraftChunkRequest) String() string { func (*RejectDraftChunkRequest) ProtoMessage() {} func (x *RejectDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[152] + mi := &file_openshell_proto_msgTypes[156] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11019,7 +11422,7 @@ func (x *RejectDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RejectDraftChunkRequest.ProtoReflect.Descriptor instead. func (*RejectDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{152} + return file_openshell_proto_rawDescGZIP(), []int{156} } func (x *RejectDraftChunkRequest) GetName() string { @@ -11058,7 +11461,7 @@ type RejectDraftChunkResponse struct { func (x *RejectDraftChunkResponse) Reset() { *x = RejectDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[153] + mi := &file_openshell_proto_msgTypes[157] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11070,7 +11473,7 @@ func (x *RejectDraftChunkResponse) String() string { func (*RejectDraftChunkResponse) ProtoMessage() {} func (x *RejectDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[153] + mi := &file_openshell_proto_msgTypes[157] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11083,7 +11486,7 @@ func (x *RejectDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RejectDraftChunkResponse.ProtoReflect.Descriptor instead. func (*RejectDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{153} + return file_openshell_proto_rawDescGZIP(), []int{157} } // Approve all pending chunks. @@ -11101,7 +11504,7 @@ type ApproveAllDraftChunksRequest struct { func (x *ApproveAllDraftChunksRequest) Reset() { *x = ApproveAllDraftChunksRequest{} - mi := &file_openshell_proto_msgTypes[154] + mi := &file_openshell_proto_msgTypes[158] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11113,7 +11516,7 @@ func (x *ApproveAllDraftChunksRequest) String() string { func (*ApproveAllDraftChunksRequest) ProtoMessage() {} func (x *ApproveAllDraftChunksRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[154] + mi := &file_openshell_proto_msgTypes[158] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11126,7 +11529,7 @@ func (x *ApproveAllDraftChunksRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveAllDraftChunksRequest.ProtoReflect.Descriptor instead. func (*ApproveAllDraftChunksRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{154} + return file_openshell_proto_rawDescGZIP(), []int{158} } func (x *ApproveAllDraftChunksRequest) GetName() string { @@ -11166,7 +11569,7 @@ type ApproveAllDraftChunksResponse struct { func (x *ApproveAllDraftChunksResponse) Reset() { *x = ApproveAllDraftChunksResponse{} - mi := &file_openshell_proto_msgTypes[155] + mi := &file_openshell_proto_msgTypes[159] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11178,7 +11581,7 @@ func (x *ApproveAllDraftChunksResponse) String() string { func (*ApproveAllDraftChunksResponse) ProtoMessage() {} func (x *ApproveAllDraftChunksResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[155] + mi := &file_openshell_proto_msgTypes[159] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11191,7 +11594,7 @@ func (x *ApproveAllDraftChunksResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveAllDraftChunksResponse.ProtoReflect.Descriptor instead. func (*ApproveAllDraftChunksResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{155} + return file_openshell_proto_rawDescGZIP(), []int{159} } func (x *ApproveAllDraftChunksResponse) GetPolicyVersion() uint32 { @@ -11239,7 +11642,7 @@ type EditDraftChunkRequest struct { func (x *EditDraftChunkRequest) Reset() { *x = EditDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[156] + mi := &file_openshell_proto_msgTypes[160] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11251,7 +11654,7 @@ func (x *EditDraftChunkRequest) String() string { func (*EditDraftChunkRequest) ProtoMessage() {} func (x *EditDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[156] + mi := &file_openshell_proto_msgTypes[160] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11264,7 +11667,7 @@ func (x *EditDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use EditDraftChunkRequest.ProtoReflect.Descriptor instead. func (*EditDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{156} + return file_openshell_proto_rawDescGZIP(), []int{160} } func (x *EditDraftChunkRequest) GetName() string { @@ -11303,7 +11706,7 @@ type EditDraftChunkResponse struct { func (x *EditDraftChunkResponse) Reset() { *x = EditDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[157] + mi := &file_openshell_proto_msgTypes[161] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11315,7 +11718,7 @@ func (x *EditDraftChunkResponse) String() string { func (*EditDraftChunkResponse) ProtoMessage() {} func (x *EditDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[157] + mi := &file_openshell_proto_msgTypes[161] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11328,7 +11731,7 @@ func (x *EditDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use EditDraftChunkResponse.ProtoReflect.Descriptor instead. func (*EditDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{157} + return file_openshell_proto_rawDescGZIP(), []int{161} } // Reverse an approval (remove merged rule from active policy). @@ -11346,7 +11749,7 @@ type UndoDraftChunkRequest struct { func (x *UndoDraftChunkRequest) Reset() { *x = UndoDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[158] + mi := &file_openshell_proto_msgTypes[162] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11358,7 +11761,7 @@ func (x *UndoDraftChunkRequest) String() string { func (*UndoDraftChunkRequest) ProtoMessage() {} func (x *UndoDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[158] + mi := &file_openshell_proto_msgTypes[162] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11371,7 +11774,7 @@ func (x *UndoDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UndoDraftChunkRequest.ProtoReflect.Descriptor instead. func (*UndoDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{158} + return file_openshell_proto_rawDescGZIP(), []int{162} } func (x *UndoDraftChunkRequest) GetName() string { @@ -11407,7 +11810,7 @@ type UndoDraftChunkResponse struct { func (x *UndoDraftChunkResponse) Reset() { *x = UndoDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[159] + mi := &file_openshell_proto_msgTypes[163] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11419,7 +11822,7 @@ func (x *UndoDraftChunkResponse) String() string { func (*UndoDraftChunkResponse) ProtoMessage() {} func (x *UndoDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[159] + mi := &file_openshell_proto_msgTypes[163] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11432,7 +11835,7 @@ func (x *UndoDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UndoDraftChunkResponse.ProtoReflect.Descriptor instead. func (*UndoDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{159} + return file_openshell_proto_rawDescGZIP(), []int{163} } func (x *UndoDraftChunkResponse) GetPolicyVersion() uint32 { @@ -11462,7 +11865,7 @@ type ClearDraftChunksRequest struct { func (x *ClearDraftChunksRequest) Reset() { *x = ClearDraftChunksRequest{} - mi := &file_openshell_proto_msgTypes[160] + mi := &file_openshell_proto_msgTypes[164] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11474,7 +11877,7 @@ func (x *ClearDraftChunksRequest) String() string { func (*ClearDraftChunksRequest) ProtoMessage() {} func (x *ClearDraftChunksRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[160] + mi := &file_openshell_proto_msgTypes[164] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11487,7 +11890,7 @@ func (x *ClearDraftChunksRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ClearDraftChunksRequest.ProtoReflect.Descriptor instead. func (*ClearDraftChunksRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{160} + return file_openshell_proto_rawDescGZIP(), []int{164} } func (x *ClearDraftChunksRequest) GetName() string { @@ -11514,7 +11917,7 @@ type ClearDraftChunksResponse struct { func (x *ClearDraftChunksResponse) Reset() { *x = ClearDraftChunksResponse{} - mi := &file_openshell_proto_msgTypes[161] + mi := &file_openshell_proto_msgTypes[165] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11526,7 +11929,7 @@ func (x *ClearDraftChunksResponse) String() string { func (*ClearDraftChunksResponse) ProtoMessage() {} func (x *ClearDraftChunksResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[161] + mi := &file_openshell_proto_msgTypes[165] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11539,7 +11942,7 @@ func (x *ClearDraftChunksResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ClearDraftChunksResponse.ProtoReflect.Descriptor instead. func (*ClearDraftChunksResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{161} + return file_openshell_proto_rawDescGZIP(), []int{165} } func (x *ClearDraftChunksResponse) GetChunksCleared() uint32 { @@ -11562,7 +11965,7 @@ type GetDraftHistoryRequest struct { func (x *GetDraftHistoryRequest) Reset() { *x = GetDraftHistoryRequest{} - mi := &file_openshell_proto_msgTypes[162] + mi := &file_openshell_proto_msgTypes[166] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11574,7 +11977,7 @@ func (x *GetDraftHistoryRequest) String() string { func (*GetDraftHistoryRequest) ProtoMessage() {} func (x *GetDraftHistoryRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[162] + mi := &file_openshell_proto_msgTypes[166] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11587,7 +11990,7 @@ func (x *GetDraftHistoryRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftHistoryRequest.ProtoReflect.Descriptor instead. func (*GetDraftHistoryRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{162} + return file_openshell_proto_rawDescGZIP(), []int{166} } func (x *GetDraftHistoryRequest) GetName() string { @@ -11621,7 +12024,7 @@ type DraftHistoryEntry struct { func (x *DraftHistoryEntry) Reset() { *x = DraftHistoryEntry{} - mi := &file_openshell_proto_msgTypes[163] + mi := &file_openshell_proto_msgTypes[167] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11633,7 +12036,7 @@ func (x *DraftHistoryEntry) String() string { func (*DraftHistoryEntry) ProtoMessage() {} func (x *DraftHistoryEntry) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[163] + mi := &file_openshell_proto_msgTypes[167] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11646,7 +12049,7 @@ func (x *DraftHistoryEntry) ProtoReflect() protoreflect.Message { // Deprecated: Use DraftHistoryEntry.ProtoReflect.Descriptor instead. func (*DraftHistoryEntry) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{163} + return file_openshell_proto_rawDescGZIP(), []int{167} } func (x *DraftHistoryEntry) GetTimestampMs() int64 { @@ -11687,7 +12090,7 @@ type GetDraftHistoryResponse struct { func (x *GetDraftHistoryResponse) Reset() { *x = GetDraftHistoryResponse{} - mi := &file_openshell_proto_msgTypes[164] + mi := &file_openshell_proto_msgTypes[168] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11699,7 +12102,7 @@ func (x *GetDraftHistoryResponse) String() string { func (*GetDraftHistoryResponse) ProtoMessage() {} func (x *GetDraftHistoryResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[164] + mi := &file_openshell_proto_msgTypes[168] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11712,7 +12115,7 @@ func (x *GetDraftHistoryResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftHistoryResponse.ProtoReflect.Descriptor instead. func (*GetDraftHistoryResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{164} + return file_openshell_proto_rawDescGZIP(), []int{168} } func (x *GetDraftHistoryResponse) GetEntries() []*DraftHistoryEntry { @@ -11741,7 +12144,7 @@ type PolicyRevisionPayload struct { func (x *PolicyRevisionPayload) Reset() { *x = PolicyRevisionPayload{} - mi := &file_openshell_proto_msgTypes[165] + mi := &file_openshell_proto_msgTypes[169] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11753,7 +12156,7 @@ func (x *PolicyRevisionPayload) String() string { func (*PolicyRevisionPayload) ProtoMessage() {} func (x *PolicyRevisionPayload) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[165] + mi := &file_openshell_proto_msgTypes[169] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11766,7 +12169,7 @@ func (x *PolicyRevisionPayload) ProtoReflect() protoreflect.Message { // Deprecated: Use PolicyRevisionPayload.ProtoReflect.Descriptor instead. func (*PolicyRevisionPayload) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{165} + return file_openshell_proto_rawDescGZIP(), []int{169} } func (x *PolicyRevisionPayload) GetPolicy() *sandboxv1.SandboxPolicy { @@ -11839,7 +12242,7 @@ type DraftChunkPayload struct { func (x *DraftChunkPayload) Reset() { *x = DraftChunkPayload{} - mi := &file_openshell_proto_msgTypes[166] + mi := &file_openshell_proto_msgTypes[170] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11851,7 +12254,7 @@ func (x *DraftChunkPayload) String() string { func (*DraftChunkPayload) ProtoMessage() {} func (x *DraftChunkPayload) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[166] + mi := &file_openshell_proto_msgTypes[170] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11864,7 +12267,7 @@ func (x *DraftChunkPayload) ProtoReflect() protoreflect.Message { // Deprecated: Use DraftChunkPayload.ProtoReflect.Descriptor instead. func (*DraftChunkPayload) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{166} + return file_openshell_proto_rawDescGZIP(), []int{170} } func (x *DraftChunkPayload) GetRuleName() string { @@ -11970,7 +12373,7 @@ type StoredPolicyRevision struct { func (x *StoredPolicyRevision) Reset() { *x = StoredPolicyRevision{} - mi := &file_openshell_proto_msgTypes[167] + mi := &file_openshell_proto_msgTypes[171] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11982,7 +12385,7 @@ func (x *StoredPolicyRevision) String() string { func (*StoredPolicyRevision) ProtoMessage() {} func (x *StoredPolicyRevision) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[167] + mi := &file_openshell_proto_msgTypes[171] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11995,7 +12398,7 @@ func (x *StoredPolicyRevision) ProtoReflect() protoreflect.Message { // Deprecated: Use StoredPolicyRevision.ProtoReflect.Descriptor instead. func (*StoredPolicyRevision) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{167} + return file_openshell_proto_rawDescGZIP(), []int{171} } func (x *StoredPolicyRevision) GetId() string { @@ -12098,7 +12501,7 @@ type StoredDraftChunk struct { func (x *StoredDraftChunk) Reset() { *x = StoredDraftChunk{} - mi := &file_openshell_proto_msgTypes[168] + mi := &file_openshell_proto_msgTypes[172] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12110,7 +12513,7 @@ func (x *StoredDraftChunk) String() string { func (*StoredDraftChunk) ProtoMessage() {} func (x *StoredDraftChunk) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[168] + mi := &file_openshell_proto_msgTypes[172] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12123,7 +12526,7 @@ func (x *StoredDraftChunk) ProtoReflect() protoreflect.Message { // Deprecated: Use StoredDraftChunk.ProtoReflect.Descriptor instead. func (*StoredDraftChunk) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{168} + return file_openshell_proto_rawDescGZIP(), []int{172} } func (x *StoredDraftChunk) GetId() string { @@ -12272,7 +12675,7 @@ type CreateWorkspaceRequest struct { func (x *CreateWorkspaceRequest) Reset() { *x = CreateWorkspaceRequest{} - mi := &file_openshell_proto_msgTypes[169] + mi := &file_openshell_proto_msgTypes[173] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12284,7 +12687,7 @@ func (x *CreateWorkspaceRequest) String() string { func (*CreateWorkspaceRequest) ProtoMessage() {} func (x *CreateWorkspaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[169] + mi := &file_openshell_proto_msgTypes[173] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12297,7 +12700,7 @@ func (x *CreateWorkspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateWorkspaceRequest.ProtoReflect.Descriptor instead. func (*CreateWorkspaceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{169} + return file_openshell_proto_rawDescGZIP(), []int{173} } func (x *CreateWorkspaceRequest) GetName() string { @@ -12324,7 +12727,7 @@ type CreateWorkspaceResponse struct { func (x *CreateWorkspaceResponse) Reset() { *x = CreateWorkspaceResponse{} - mi := &file_openshell_proto_msgTypes[170] + mi := &file_openshell_proto_msgTypes[174] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12336,7 +12739,7 @@ func (x *CreateWorkspaceResponse) String() string { func (*CreateWorkspaceResponse) ProtoMessage() {} func (x *CreateWorkspaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[170] + mi := &file_openshell_proto_msgTypes[174] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12349,7 +12752,7 @@ func (x *CreateWorkspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateWorkspaceResponse.ProtoReflect.Descriptor instead. func (*CreateWorkspaceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{170} + return file_openshell_proto_rawDescGZIP(), []int{174} } func (x *CreateWorkspaceResponse) GetWorkspace() *datamodelv1.Workspace { @@ -12370,7 +12773,7 @@ type GetWorkspaceRequest struct { func (x *GetWorkspaceRequest) Reset() { *x = GetWorkspaceRequest{} - mi := &file_openshell_proto_msgTypes[171] + mi := &file_openshell_proto_msgTypes[175] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12382,7 +12785,7 @@ func (x *GetWorkspaceRequest) String() string { func (*GetWorkspaceRequest) ProtoMessage() {} func (x *GetWorkspaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[171] + mi := &file_openshell_proto_msgTypes[175] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12395,7 +12798,7 @@ func (x *GetWorkspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetWorkspaceRequest.ProtoReflect.Descriptor instead. func (*GetWorkspaceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{171} + return file_openshell_proto_rawDescGZIP(), []int{175} } func (x *GetWorkspaceRequest) GetName() string { @@ -12415,7 +12818,7 @@ type GetWorkspaceResponse struct { func (x *GetWorkspaceResponse) Reset() { *x = GetWorkspaceResponse{} - mi := &file_openshell_proto_msgTypes[172] + mi := &file_openshell_proto_msgTypes[176] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12427,7 +12830,7 @@ func (x *GetWorkspaceResponse) String() string { func (*GetWorkspaceResponse) ProtoMessage() {} func (x *GetWorkspaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[172] + mi := &file_openshell_proto_msgTypes[176] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12440,7 +12843,7 @@ func (x *GetWorkspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetWorkspaceResponse.ProtoReflect.Descriptor instead. func (*GetWorkspaceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{172} + return file_openshell_proto_rawDescGZIP(), []int{176} } func (x *GetWorkspaceResponse) GetWorkspace() *datamodelv1.Workspace { @@ -12463,7 +12866,7 @@ type ListWorkspacesRequest struct { func (x *ListWorkspacesRequest) Reset() { *x = ListWorkspacesRequest{} - mi := &file_openshell_proto_msgTypes[173] + mi := &file_openshell_proto_msgTypes[177] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12475,7 +12878,7 @@ func (x *ListWorkspacesRequest) String() string { func (*ListWorkspacesRequest) ProtoMessage() {} func (x *ListWorkspacesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[173] + mi := &file_openshell_proto_msgTypes[177] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12488,7 +12891,7 @@ func (x *ListWorkspacesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspacesRequest.ProtoReflect.Descriptor instead. func (*ListWorkspacesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{173} + return file_openshell_proto_rawDescGZIP(), []int{177} } func (x *ListWorkspacesRequest) GetLimit() uint32 { @@ -12522,7 +12925,7 @@ type ListWorkspacesResponse struct { func (x *ListWorkspacesResponse) Reset() { *x = ListWorkspacesResponse{} - mi := &file_openshell_proto_msgTypes[174] + mi := &file_openshell_proto_msgTypes[178] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12534,7 +12937,7 @@ func (x *ListWorkspacesResponse) String() string { func (*ListWorkspacesResponse) ProtoMessage() {} func (x *ListWorkspacesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[174] + mi := &file_openshell_proto_msgTypes[178] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12547,7 +12950,7 @@ func (x *ListWorkspacesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspacesResponse.ProtoReflect.Descriptor instead. func (*ListWorkspacesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{174} + return file_openshell_proto_rawDescGZIP(), []int{178} } func (x *ListWorkspacesResponse) GetWorkspaces() []*datamodelv1.Workspace { @@ -12568,7 +12971,7 @@ type DeleteWorkspaceRequest struct { func (x *DeleteWorkspaceRequest) Reset() { *x = DeleteWorkspaceRequest{} - mi := &file_openshell_proto_msgTypes[175] + mi := &file_openshell_proto_msgTypes[179] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12580,7 +12983,7 @@ func (x *DeleteWorkspaceRequest) String() string { func (*DeleteWorkspaceRequest) ProtoMessage() {} func (x *DeleteWorkspaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[175] + mi := &file_openshell_proto_msgTypes[179] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12593,7 +12996,7 @@ func (x *DeleteWorkspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteWorkspaceRequest.ProtoReflect.Descriptor instead. func (*DeleteWorkspaceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{175} + return file_openshell_proto_rawDescGZIP(), []int{179} } func (x *DeleteWorkspaceRequest) GetName() string { @@ -12613,7 +13016,7 @@ type DeleteWorkspaceResponse struct { func (x *DeleteWorkspaceResponse) Reset() { *x = DeleteWorkspaceResponse{} - mi := &file_openshell_proto_msgTypes[176] + mi := &file_openshell_proto_msgTypes[180] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12625,7 +13028,7 @@ func (x *DeleteWorkspaceResponse) String() string { func (*DeleteWorkspaceResponse) ProtoMessage() {} func (x *DeleteWorkspaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[176] + mi := &file_openshell_proto_msgTypes[180] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12638,7 +13041,7 @@ func (x *DeleteWorkspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteWorkspaceResponse.ProtoReflect.Descriptor instead. func (*DeleteWorkspaceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{176} + return file_openshell_proto_rawDescGZIP(), []int{180} } func (x *DeleteWorkspaceResponse) GetDeleted() bool { @@ -12662,7 +13065,7 @@ type WorkspaceMember struct { func (x *WorkspaceMember) Reset() { *x = WorkspaceMember{} - mi := &file_openshell_proto_msgTypes[177] + mi := &file_openshell_proto_msgTypes[181] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12674,7 +13077,7 @@ func (x *WorkspaceMember) String() string { func (*WorkspaceMember) ProtoMessage() {} func (x *WorkspaceMember) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[177] + mi := &file_openshell_proto_msgTypes[181] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12687,7 +13090,7 @@ func (x *WorkspaceMember) ProtoReflect() protoreflect.Message { // Deprecated: Use WorkspaceMember.ProtoReflect.Descriptor instead. func (*WorkspaceMember) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{177} + return file_openshell_proto_rawDescGZIP(), []int{181} } func (x *WorkspaceMember) GetMetadata() *datamodelv1.ObjectMeta { @@ -12726,7 +13129,7 @@ type AddWorkspaceMemberRequest struct { func (x *AddWorkspaceMemberRequest) Reset() { *x = AddWorkspaceMemberRequest{} - mi := &file_openshell_proto_msgTypes[178] + mi := &file_openshell_proto_msgTypes[182] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12738,7 +13141,7 @@ func (x *AddWorkspaceMemberRequest) String() string { func (*AddWorkspaceMemberRequest) ProtoMessage() {} func (x *AddWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[178] + mi := &file_openshell_proto_msgTypes[182] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12751,7 +13154,7 @@ func (x *AddWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use AddWorkspaceMemberRequest.ProtoReflect.Descriptor instead. func (*AddWorkspaceMemberRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{178} + return file_openshell_proto_rawDescGZIP(), []int{182} } func (x *AddWorkspaceMemberRequest) GetWorkspace() string { @@ -12785,7 +13188,7 @@ type AddWorkspaceMemberResponse struct { func (x *AddWorkspaceMemberResponse) Reset() { *x = AddWorkspaceMemberResponse{} - mi := &file_openshell_proto_msgTypes[179] + mi := &file_openshell_proto_msgTypes[183] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12797,7 +13200,7 @@ func (x *AddWorkspaceMemberResponse) String() string { func (*AddWorkspaceMemberResponse) ProtoMessage() {} func (x *AddWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[179] + mi := &file_openshell_proto_msgTypes[183] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12810,7 +13213,7 @@ func (x *AddWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use AddWorkspaceMemberResponse.ProtoReflect.Descriptor instead. func (*AddWorkspaceMemberResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{179} + return file_openshell_proto_rawDescGZIP(), []int{183} } func (x *AddWorkspaceMemberResponse) GetMember() *WorkspaceMember { @@ -12833,7 +13236,7 @@ type RemoveWorkspaceMemberRequest struct { func (x *RemoveWorkspaceMemberRequest) Reset() { *x = RemoveWorkspaceMemberRequest{} - mi := &file_openshell_proto_msgTypes[180] + mi := &file_openshell_proto_msgTypes[184] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12845,7 +13248,7 @@ func (x *RemoveWorkspaceMemberRequest) String() string { func (*RemoveWorkspaceMemberRequest) ProtoMessage() {} func (x *RemoveWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[180] + mi := &file_openshell_proto_msgTypes[184] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12858,7 +13261,7 @@ func (x *RemoveWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveWorkspaceMemberRequest.ProtoReflect.Descriptor instead. func (*RemoveWorkspaceMemberRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{180} + return file_openshell_proto_rawDescGZIP(), []int{184} } func (x *RemoveWorkspaceMemberRequest) GetWorkspace() string { @@ -12885,7 +13288,7 @@ type RemoveWorkspaceMemberResponse struct { func (x *RemoveWorkspaceMemberResponse) Reset() { *x = RemoveWorkspaceMemberResponse{} - mi := &file_openshell_proto_msgTypes[181] + mi := &file_openshell_proto_msgTypes[185] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12897,7 +13300,7 @@ func (x *RemoveWorkspaceMemberResponse) String() string { func (*RemoveWorkspaceMemberResponse) ProtoMessage() {} func (x *RemoveWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[181] + mi := &file_openshell_proto_msgTypes[185] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12910,7 +13313,7 @@ func (x *RemoveWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveWorkspaceMemberResponse.ProtoReflect.Descriptor instead. func (*RemoveWorkspaceMemberResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{181} + return file_openshell_proto_rawDescGZIP(), []int{185} } func (x *RemoveWorkspaceMemberResponse) GetRemoved() bool { @@ -12933,7 +13336,7 @@ type ListWorkspaceMembersRequest struct { func (x *ListWorkspaceMembersRequest) Reset() { *x = ListWorkspaceMembersRequest{} - mi := &file_openshell_proto_msgTypes[182] + mi := &file_openshell_proto_msgTypes[186] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12945,7 +13348,7 @@ func (x *ListWorkspaceMembersRequest) String() string { func (*ListWorkspaceMembersRequest) ProtoMessage() {} func (x *ListWorkspaceMembersRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[182] + mi := &file_openshell_proto_msgTypes[186] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12958,7 +13361,7 @@ func (x *ListWorkspaceMembersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspaceMembersRequest.ProtoReflect.Descriptor instead. func (*ListWorkspaceMembersRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{182} + return file_openshell_proto_rawDescGZIP(), []int{186} } func (x *ListWorkspaceMembersRequest) GetWorkspace() string { @@ -12992,7 +13395,7 @@ type ListWorkspaceMembersResponse struct { func (x *ListWorkspaceMembersResponse) Reset() { *x = ListWorkspaceMembersResponse{} - mi := &file_openshell_proto_msgTypes[183] + mi := &file_openshell_proto_msgTypes[187] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13004,7 +13407,7 @@ func (x *ListWorkspaceMembersResponse) String() string { func (*ListWorkspaceMembersResponse) ProtoMessage() {} func (x *ListWorkspaceMembersResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[183] + mi := &file_openshell_proto_msgTypes[187] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13017,7 +13420,7 @@ func (x *ListWorkspaceMembersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspaceMembersResponse.ProtoReflect.Descriptor instead. func (*ListWorkspaceMembersResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{183} + return file_openshell_proto_rawDescGZIP(), []int{187} } func (x *ListWorkspaceMembersResponse) GetMembers() []*WorkspaceMember { @@ -13045,7 +13448,7 @@ type ExtensionServiceCredential struct { func (x *ExtensionServiceCredential) Reset() { *x = ExtensionServiceCredential{} - mi := &file_openshell_proto_msgTypes[184] + mi := &file_openshell_proto_msgTypes[188] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13057,7 +13460,7 @@ func (x *ExtensionServiceCredential) String() string { func (*ExtensionServiceCredential) ProtoMessage() {} func (x *ExtensionServiceCredential) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[184] + mi := &file_openshell_proto_msgTypes[188] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13070,7 +13473,7 @@ func (x *ExtensionServiceCredential) ProtoReflect() protoreflect.Message { // Deprecated: Use ExtensionServiceCredential.ProtoReflect.Descriptor instead. func (*ExtensionServiceCredential) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{184} + return file_openshell_proto_rawDescGZIP(), []int{188} } func (x *ExtensionServiceCredential) GetServiceName() string { @@ -13127,27 +13530,37 @@ const file_openshell_proto_rawDesc = "" + "\x0fcompute_drivers\x18\x03 \x03(\v2\x1f.openshell.v1.ComputeDriverInfoR\x0ecomputeDrivers\"t\n" + "\x11ComputeDriverInfo\x12\x12\n" + "\x04name\x18\x01 \x01(\tR\x04name\x12K\n" + - "\fcapabilities\x18\x02 \x01(\v2'.openshell.v1.ComputeDriverCapabilitiesR\fcapabilities\"c\n" + + "\fcapabilities\x18\x02 \x01(\v2'.openshell.v1.ComputeDriverCapabilitiesR\fcapabilities\"\x97\x01\n" + "\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\x122\n" + + "\x15supports_main_process\x18\x03 \x01(\bR\x13supportsMainProcess\"\xd8\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\"\xd7\x03\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\"\x99\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" + "\btemplate\x18\x06 \x01(\v2\x1d.openshell.v1.SandboxTemplateR\btemplate\x12;\n" + "\x06policy\x18\a \x01(\v2#.openshell.sandbox.v1.SandboxPolicyR\x06policy\x12\x1c\n" + "\tproviders\x18\b \x03(\tR\tproviders\x12W\n" + - "\x15resource_requirements\x18\t \x01(\v2\".openshell.v1.ResourceRequirementsR\x14resourceRequirements\x1a>\n" + + "\x15resource_requirements\x18\t \x01(\v2\".openshell.v1.ResourceRequirementsR\x14resourceRequirements\x12@\n" + + "\fmain_process\x18\f \x01(\v2\x1d.openshell.v1.MainProcessSpecR\vmainProcess\x1a>\n" + "\x10EnvironmentEntry\x12\x10\n" + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01J\x04\b\n" + "\x10\vJ\x04\b\v\x10\fR\n" + - "gpu_deviceR\x16proposal_approval_mode\"O\n" + + "gpu_deviceR\x16proposal_approval_mode\"\x86\x02\n" + + "\x0fMainProcessSpec\x12\x18\n" + + "\acommand\x18\x01 \x03(\tR\acommand\x12P\n" + + "\venvironment\x18\x02 \x03(\v2..openshell.v1.MainProcessSpec.EnvironmentEntryR\venvironment\x12+\n" + + "\x11working_directory\x18\x03 \x01(\tR\x10workingDirectory\x12\x1a\n" + + "\bterminal\x18\x04 \x01(\bR\bterminal\x1a>\n" + + "\x10EnvironmentEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"O\n" + "\x14ResourceRequirements\x127\n" + "\x03gpu\x18\x01 \x01(\v2%.openshell.v1.GpuResourceRequirementsR\x03gpu\">\n" + "\x17GpuResourceRequirements\x12\x19\n" + @@ -13174,7 +13587,7 @@ const file_openshell_proto_rawDesc = "" + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01B\x12\n" + "\x10_user_namespacesJ\x04\b\t\x10\n" + - "R\x16volume_claim_templates\"\xb1\x02\n" + + "R\x16volume_claim_templates\"\xf5\x02\n" + "\rSandboxStatus\x12!\n" + "\fsandbox_name\x18\x01 \x01(\tR\vsandboxName\x12\x1b\n" + "\tagent_pod\x18\x02 \x01(\tR\bagentPod\x12\x19\n" + @@ -13185,7 +13598,20 @@ const file_openshell_proto_rawDesc = "" + "conditions\x18\x05 \x03(\v2\x1e.openshell.v1.SandboxConditionR\n" + "conditions\x120\n" + "\x05phase\x18\x06 \x01(\x0e2\x1a.openshell.v1.SandboxPhaseR\x05phase\x124\n" + - "\x16current_policy_version\x18\a \x01(\rR\x14currentPolicyVersion\"\xa2\x01\n" + + "\x16current_policy_version\x18\a \x01(\rR\x14currentPolicyVersion\x12B\n" + + "\fmain_process\x18\b \x01(\v2\x1f.openshell.v1.MainProcessStatusR\vmainProcess\"\x8b\x02\n" + + "\x11MainProcessStatus\x124\n" + + "\x05state\x18\x01 \x01(\x0e2\x1e.openshell.v1.MainProcessStateR\x05state\x12\x1e\n" + + "\n" + + "generation\x18\x02 \x01(\tR\n" + + "generation\x12 \n" + + "\texit_code\x18\x03 \x01(\x05H\x00R\bexitCode\x88\x01\x01\x12\x1b\n" + + "\x06signal\x18\x04 \x01(\x05H\x01R\x06signal\x88\x01\x01\x12\"\n" + + "\rstarted_at_ms\x18\x05 \x01(\x03R\vstartedAtMs\x12$\n" + + "\x0efinished_at_ms\x18\x06 \x01(\x03R\ffinishedAtMsB\f\n" + + "\n" + + "_exit_codeB\t\n" + + "\a_signal\"\xa2\x01\n" + "\x10SandboxCondition\x12\x12\n" + "\x04type\x18\x01 \x01(\tR\x04type\x12\x16\n" + "\x06status\x18\x02 \x01(\tR\x06status\x12\x16\n" + @@ -13765,14 +14191,15 @@ const file_openshell_proto_rawDesc = "" + "\x17PushSandboxLogsResponse\"m\n" + "\x16GetSandboxLogsResponse\x120\n" + "\x04logs\x18\x01 \x03(\v2\x1c.openshell.v1.SandboxLogLineR\x04logs\x12!\n" + - "\fbuffer_total\x18\x02 \x01(\rR\vbufferTotal\"\xa2\x02\n" + + "\fbuffer_total\x18\x02 \x01(\rR\vbufferTotal\"\xef\x02\n" + "\x11SupervisorMessage\x125\n" + "\x05hello\x18\x01 \x01(\v2\x1d.openshell.v1.SupervisorHelloH\x00R\x05hello\x12A\n" + "\theartbeat\x18\x02 \x01(\v2!.openshell.v1.SupervisorHeartbeatH\x00R\theartbeat\x12K\n" + "\x11relay_open_result\x18\x03 \x01(\v2\x1d.openshell.v1.RelayOpenResultH\x00R\x0frelayOpenResult\x12;\n" + "\vrelay_close\x18\x04 \x01(\v2\x18.openshell.v1.RelayCloseH\x00R\n" + - "relayCloseB\t\n" + - "\apayload\"\xea\x02\n" + + "relayClose\x12K\n" + + "\x11main_process_exit\x18\x05 \x01(\v2\x1d.openshell.v1.MainProcessExitH\x00R\x0fmainProcessExitB\t\n" + + "\apayload\"\xc1\x03\n" + "\x0eGatewayMessage\x12J\n" + "\x10session_accepted\x18\x01 \x01(\v2\x1d.openshell.v1.SessionAcceptedH\x00R\x0fsessionAccepted\x12J\n" + "\x10session_rejected\x18\x02 \x01(\v2\x1d.openshell.v1.SessionRejectedH\x00R\x0fsessionRejected\x12>\n" + @@ -13780,13 +14207,15 @@ const file_openshell_proto_rawDesc = "" + "\n" + "relay_open\x18\x04 \x01(\v2\x17.openshell.v1.RelayOpenH\x00R\trelayOpen\x12;\n" + "\vrelay_close\x18\x05 \x01(\v2\x18.openshell.v1.RelayCloseH\x00R\n" + - "relayCloseB\t\n" + - "\apayload\"Q\n" + + "relayClose\x12U\n" + + "\x15main_process_exit_ack\x18\x06 \x01(\v2 .openshell.v1.MainProcessExitAckH\x00R\x12mainProcessExitAckB\t\n" + + "\apayload\"{\n" + "\x0fSupervisorHello\x12\x1d\n" + "\n" + "sandbox_id\x18\x01 \x01(\tR\tsandboxId\x12\x1f\n" + "\vinstance_id\x18\x02 \x01(\tR\n" + - "instanceId\"h\n" + + "instanceId\x12(\n" + + "\x10exit_report_only\x18\x03 \x01(\bR\x0eexitReportOnly\"h\n" + "\x0fSessionAccepted\x12\x1d\n" + "\n" + "session_id\x18\x01 \x01(\tR\tsessionId\x126\n" + @@ -13794,7 +14223,22 @@ const file_openshell_proto_rawDesc = "" + "\x0fSessionRejected\x12\x16\n" + "\x06reason\x18\x01 \x01(\tR\x06reason\"\x15\n" + "\x13SupervisorHeartbeat\"\x12\n" + - "\x10GatewayHeartbeat\"\xb7\x01\n" + + "\x10GatewayHeartbeat\"\xd3\x01\n" + + "\x0fMainProcessExit\x12\x1e\n" + + "\n" + + "generation\x18\x01 \x01(\tR\n" + + "generation\x12 \n" + + "\texit_code\x18\x02 \x01(\x05H\x00R\bexitCode\x88\x01\x01\x12\x1b\n" + + "\x06signal\x18\x03 \x01(\x05H\x01R\x06signal\x88\x01\x01\x12\"\n" + + "\rstarted_at_ms\x18\x04 \x01(\x03R\vstartedAtMs\x12$\n" + + "\x0efinished_at_ms\x18\x05 \x01(\x03R\ffinishedAtMsB\f\n" + + "\n" + + "_exit_codeB\t\n" + + "\a_signal\"4\n" + + "\x12MainProcessExitAck\x12\x1e\n" + + "\n" + + "generation\x18\x01 \x01(\tR\n" + + "generation\"\xb7\x01\n" + "\tRelayOpen\x12\x1d\n" + "\n" + "channel_id\x18\x01 \x01(\tR\tchannelId\x120\n" + @@ -14093,7 +14537,11 @@ const file_openshell_proto_rawDesc = "" + "\x1aExtensionServiceCredential\x12!\n" + "\fservice_name\x18\x01 \x01(\tR\vserviceName\x12\x1a\n" + "\x05token\x18\x02 \x01(\tB\x04\x88\xb5\x18\x01R\x05token\x12\"\n" + - "\rexpires_at_ms\x18\x03 \x01(\x03R\vexpiresAtMs*\x89\x02\n" + + "\rexpires_at_ms\x18\x03 \x01(\x03R\vexpiresAtMs*u\n" + + "\x10MainProcessState\x12\"\n" + + "\x1eMAIN_PROCESS_STATE_UNSPECIFIED\x10\x00\x12\x1e\n" + + "\x1aMAIN_PROCESS_STATE_RUNNING\x10\x01\x12\x1d\n" + + "\x19MAIN_PROCESS_STATE_EXITED\x10\x02*\x89\x02\n" + "\fSandboxPhase\x12\x1d\n" + "\x19SANDBOX_PHASE_UNSPECIFIED\x10\x00\x12\x1e\n" + "\x1aSANDBOX_PHASE_PROVISIONING\x10\x01\x12\x17\n" + @@ -14285,529 +14733,541 @@ func file_openshell_proto_rawDescGZIP() []byte { return file_openshell_proto_rawDescData } -var file_openshell_proto_enumTypes = make([]protoimpl.EnumInfo, 6) -var file_openshell_proto_msgTypes = make([]protoimpl.MessageInfo, 209) +var file_openshell_proto_enumTypes = make([]protoimpl.EnumInfo, 7) +var file_openshell_proto_msgTypes = make([]protoimpl.MessageInfo, 214) var file_openshell_proto_goTypes = []any{ - (SandboxPhase)(0), // 0: openshell.v1.SandboxPhase - (ProviderCredentialRefreshStrategy)(0), // 1: openshell.v1.ProviderCredentialRefreshStrategy - (ProviderProfileCategory)(0), // 2: openshell.v1.ProviderProfileCategory - (PolicyStatus)(0), // 3: openshell.v1.PolicyStatus - (ServiceStatus)(0), // 4: openshell.v1.ServiceStatus - (WorkspaceRole)(0), // 5: openshell.v1.WorkspaceRole - (*IssueSandboxTokenRequest)(nil), // 6: openshell.v1.IssueSandboxTokenRequest - (*IssueSandboxTokenResponse)(nil), // 7: openshell.v1.IssueSandboxTokenResponse - (*RefreshSandboxTokenRequest)(nil), // 8: openshell.v1.RefreshSandboxTokenRequest - (*RefreshSandboxTokenResponse)(nil), // 9: openshell.v1.RefreshSandboxTokenResponse - (*HealthRequest)(nil), // 10: openshell.v1.HealthRequest - (*HealthResponse)(nil), // 11: openshell.v1.HealthResponse - (*GetCurrentUserRequest)(nil), // 12: openshell.v1.GetCurrentUserRequest - (*GetCurrentUserResponse)(nil), // 13: openshell.v1.GetCurrentUserResponse - (*GetGatewayInfoRequest)(nil), // 14: openshell.v1.GetGatewayInfoRequest - (*GetGatewayInfoResponse)(nil), // 15: openshell.v1.GetGatewayInfoResponse - (*ComputeDriverInfo)(nil), // 16: openshell.v1.ComputeDriverInfo - (*ComputeDriverCapabilities)(nil), // 17: openshell.v1.ComputeDriverCapabilities - (*Sandbox)(nil), // 18: openshell.v1.Sandbox - (*SandboxSpec)(nil), // 19: openshell.v1.SandboxSpec - (*ResourceRequirements)(nil), // 20: openshell.v1.ResourceRequirements - (*GpuResourceRequirements)(nil), // 21: openshell.v1.GpuResourceRequirements - (*SandboxTemplate)(nil), // 22: openshell.v1.SandboxTemplate - (*SandboxStatus)(nil), // 23: openshell.v1.SandboxStatus - (*SandboxCondition)(nil), // 24: openshell.v1.SandboxCondition - (*PlatformEvent)(nil), // 25: openshell.v1.PlatformEvent - (*CreateSandboxRequest)(nil), // 26: openshell.v1.CreateSandboxRequest - (*GetSandboxRequest)(nil), // 27: openshell.v1.GetSandboxRequest - (*ListSandboxesRequest)(nil), // 28: openshell.v1.ListSandboxesRequest - (*ListSandboxProvidersRequest)(nil), // 29: openshell.v1.ListSandboxProvidersRequest - (*AttachSandboxProviderRequest)(nil), // 30: openshell.v1.AttachSandboxProviderRequest - (*DetachSandboxProviderRequest)(nil), // 31: openshell.v1.DetachSandboxProviderRequest - (*DeleteSandboxRequest)(nil), // 32: openshell.v1.DeleteSandboxRequest - (*StopSandboxRequest)(nil), // 33: openshell.v1.StopSandboxRequest - (*StartSandboxRequest)(nil), // 34: openshell.v1.StartSandboxRequest - (*SandboxResponse)(nil), // 35: openshell.v1.SandboxResponse - (*ListSandboxesResponse)(nil), // 36: openshell.v1.ListSandboxesResponse - (*ListSandboxProvidersResponse)(nil), // 37: openshell.v1.ListSandboxProvidersResponse - (*AttachSandboxProviderResponse)(nil), // 38: openshell.v1.AttachSandboxProviderResponse - (*DetachSandboxProviderResponse)(nil), // 39: openshell.v1.DetachSandboxProviderResponse - (*DeleteSandboxResponse)(nil), // 40: openshell.v1.DeleteSandboxResponse - (*CreateSshSessionRequest)(nil), // 41: openshell.v1.CreateSshSessionRequest - (*CreateSshSessionResponse)(nil), // 42: openshell.v1.CreateSshSessionResponse - (*ExposeServiceRequest)(nil), // 43: openshell.v1.ExposeServiceRequest - (*GetServiceRequest)(nil), // 44: openshell.v1.GetServiceRequest - (*ListServicesRequest)(nil), // 45: openshell.v1.ListServicesRequest - (*ListServicesResponse)(nil), // 46: openshell.v1.ListServicesResponse - (*DeleteServiceRequest)(nil), // 47: openshell.v1.DeleteServiceRequest - (*DeleteServiceResponse)(nil), // 48: openshell.v1.DeleteServiceResponse - (*ServiceEndpoint)(nil), // 49: openshell.v1.ServiceEndpoint - (*ServiceEndpointResponse)(nil), // 50: openshell.v1.ServiceEndpointResponse - (*RevokeSshSessionRequest)(nil), // 51: openshell.v1.RevokeSshSessionRequest - (*RevokeSshSessionResponse)(nil), // 52: openshell.v1.RevokeSshSessionResponse - (*ExecSandboxRequest)(nil), // 53: openshell.v1.ExecSandboxRequest - (*ExecSandboxStdout)(nil), // 54: openshell.v1.ExecSandboxStdout - (*ExecSandboxStderr)(nil), // 55: openshell.v1.ExecSandboxStderr - (*ExecSandboxExit)(nil), // 56: openshell.v1.ExecSandboxExit - (*ExecSandboxEvent)(nil), // 57: openshell.v1.ExecSandboxEvent - (*TcpForwardInit)(nil), // 58: openshell.v1.TcpForwardInit - (*TcpForwardFrame)(nil), // 59: openshell.v1.TcpForwardFrame - (*ExecSandboxInput)(nil), // 60: openshell.v1.ExecSandboxInput - (*ExecSandboxWindowResize)(nil), // 61: openshell.v1.ExecSandboxWindowResize - (*SshSession)(nil), // 62: openshell.v1.SshSession - (*WatchSandboxRequest)(nil), // 63: openshell.v1.WatchSandboxRequest - (*SandboxStreamEvent)(nil), // 64: openshell.v1.SandboxStreamEvent - (*SandboxLogLine)(nil), // 65: openshell.v1.SandboxLogLine - (*SandboxStreamWarning)(nil), // 66: openshell.v1.SandboxStreamWarning - (*CreateProviderRequest)(nil), // 67: openshell.v1.CreateProviderRequest - (*GetProviderRequest)(nil), // 68: openshell.v1.GetProviderRequest - (*ListProvidersRequest)(nil), // 69: openshell.v1.ListProvidersRequest - (*UpdateProviderRequest)(nil), // 70: openshell.v1.UpdateProviderRequest - (*DeleteProviderRequest)(nil), // 71: openshell.v1.DeleteProviderRequest - (*ProviderResponse)(nil), // 72: openshell.v1.ProviderResponse - (*ListProvidersResponse)(nil), // 73: openshell.v1.ListProvidersResponse - (*ListProviderProfilesRequest)(nil), // 74: openshell.v1.ListProviderProfilesRequest - (*GetProviderProfileRequest)(nil), // 75: openshell.v1.GetProviderProfileRequest - (*ProviderProfileImportItem)(nil), // 76: openshell.v1.ProviderProfileImportItem - (*ProviderProfileDiagnostic)(nil), // 77: openshell.v1.ProviderProfileDiagnostic - (*ProviderCredentialTokenGrantAudienceOverride)(nil), // 78: openshell.v1.ProviderCredentialTokenGrantAudienceOverride - (*ProviderCredentialTokenGrant)(nil), // 79: openshell.v1.ProviderCredentialTokenGrant - (*ProviderProfileCredential)(nil), // 80: openshell.v1.ProviderProfileCredential - (*ProviderCredentialRefreshMaterial)(nil), // 81: openshell.v1.ProviderCredentialRefreshMaterial - (*ProviderCredentialRefreshOutput)(nil), // 82: openshell.v1.ProviderCredentialRefreshOutput - (*ProviderCredentialRefresh)(nil), // 83: openshell.v1.ProviderCredentialRefresh - (*ProviderCredentialRefreshStatus)(nil), // 84: openshell.v1.ProviderCredentialRefreshStatus - (*ProviderProfileDiscovery)(nil), // 85: openshell.v1.ProviderProfileDiscovery - (*StoredProviderCredentialRefreshState)(nil), // 86: openshell.v1.StoredProviderCredentialRefreshState - (*GetProviderRefreshStatusRequest)(nil), // 87: openshell.v1.GetProviderRefreshStatusRequest - (*GetProviderRefreshStatusResponse)(nil), // 88: openshell.v1.GetProviderRefreshStatusResponse - (*ConfigureProviderRefreshRequest)(nil), // 89: openshell.v1.ConfigureProviderRefreshRequest - (*ConfigureProviderRefreshResponse)(nil), // 90: openshell.v1.ConfigureProviderRefreshResponse - (*RotateProviderCredentialRequest)(nil), // 91: openshell.v1.RotateProviderCredentialRequest - (*RotateProviderCredentialResponse)(nil), // 92: openshell.v1.RotateProviderCredentialResponse - (*DeleteProviderRefreshRequest)(nil), // 93: openshell.v1.DeleteProviderRefreshRequest - (*DeleteProviderRefreshResponse)(nil), // 94: openshell.v1.DeleteProviderRefreshResponse - (*ProviderProfile)(nil), // 95: openshell.v1.ProviderProfile - (*StoredProviderProfile)(nil), // 96: openshell.v1.StoredProviderProfile - (*ProviderProfileResponse)(nil), // 97: openshell.v1.ProviderProfileResponse - (*ListProviderProfilesResponse)(nil), // 98: openshell.v1.ListProviderProfilesResponse - (*ImportProviderProfilesRequest)(nil), // 99: openshell.v1.ImportProviderProfilesRequest - (*ImportProviderProfilesResponse)(nil), // 100: openshell.v1.ImportProviderProfilesResponse - (*UpdateProviderProfilesRequest)(nil), // 101: openshell.v1.UpdateProviderProfilesRequest - (*UpdateProviderProfilesResponse)(nil), // 102: openshell.v1.UpdateProviderProfilesResponse - (*LintProviderProfilesRequest)(nil), // 103: openshell.v1.LintProviderProfilesRequest - (*LintProviderProfilesResponse)(nil), // 104: openshell.v1.LintProviderProfilesResponse - (*DeleteProviderResponse)(nil), // 105: openshell.v1.DeleteProviderResponse - (*DeleteProviderProfileRequest)(nil), // 106: openshell.v1.DeleteProviderProfileRequest - (*DeleteProviderProfileResponse)(nil), // 107: openshell.v1.DeleteProviderProfileResponse - (*GetSandboxProviderEnvironmentRequest)(nil), // 108: openshell.v1.GetSandboxProviderEnvironmentRequest - (*StaticCredentialEndpointBinding)(nil), // 109: openshell.v1.StaticCredentialEndpointBinding - (*StaticCredentialBinding)(nil), // 110: openshell.v1.StaticCredentialBinding - (*GetSandboxProviderEnvironmentResponse)(nil), // 111: openshell.v1.GetSandboxProviderEnvironmentResponse - (*UpdateConfigRequest)(nil), // 112: openshell.v1.UpdateConfigRequest - (*PolicyMergeOperation)(nil), // 113: openshell.v1.PolicyMergeOperation - (*AddNetworkRule)(nil), // 114: openshell.v1.AddNetworkRule - (*RemoveNetworkEndpoint)(nil), // 115: openshell.v1.RemoveNetworkEndpoint - (*RemoveNetworkRule)(nil), // 116: openshell.v1.RemoveNetworkRule - (*AddDenyRules)(nil), // 117: openshell.v1.AddDenyRules - (*AddAllowRules)(nil), // 118: openshell.v1.AddAllowRules - (*RemoveNetworkBinary)(nil), // 119: openshell.v1.RemoveNetworkBinary - (*UpdateConfigResponse)(nil), // 120: openshell.v1.UpdateConfigResponse - (*GetSandboxPolicyStatusRequest)(nil), // 121: openshell.v1.GetSandboxPolicyStatusRequest - (*GetSandboxPolicyStatusResponse)(nil), // 122: openshell.v1.GetSandboxPolicyStatusResponse - (*ListSandboxPoliciesRequest)(nil), // 123: openshell.v1.ListSandboxPoliciesRequest - (*ListSandboxPoliciesResponse)(nil), // 124: openshell.v1.ListSandboxPoliciesResponse - (*ReportPolicyStatusRequest)(nil), // 125: openshell.v1.ReportPolicyStatusRequest - (*ReportPolicyStatusResponse)(nil), // 126: openshell.v1.ReportPolicyStatusResponse - (*SandboxPolicyRevision)(nil), // 127: openshell.v1.SandboxPolicyRevision - (*GetSandboxLogsRequest)(nil), // 128: openshell.v1.GetSandboxLogsRequest - (*PushSandboxLogsRequest)(nil), // 129: openshell.v1.PushSandboxLogsRequest - (*PushSandboxLogsResponse)(nil), // 130: openshell.v1.PushSandboxLogsResponse - (*GetSandboxLogsResponse)(nil), // 131: openshell.v1.GetSandboxLogsResponse - (*SupervisorMessage)(nil), // 132: openshell.v1.SupervisorMessage - (*GatewayMessage)(nil), // 133: openshell.v1.GatewayMessage - (*SupervisorHello)(nil), // 134: openshell.v1.SupervisorHello - (*SessionAccepted)(nil), // 135: openshell.v1.SessionAccepted - (*SessionRejected)(nil), // 136: openshell.v1.SessionRejected - (*SupervisorHeartbeat)(nil), // 137: openshell.v1.SupervisorHeartbeat - (*GatewayHeartbeat)(nil), // 138: openshell.v1.GatewayHeartbeat - (*RelayOpen)(nil), // 139: openshell.v1.RelayOpen - (*SshRelayTarget)(nil), // 140: openshell.v1.SshRelayTarget - (*TcpRelayTarget)(nil), // 141: openshell.v1.TcpRelayTarget - (*RelayInit)(nil), // 142: openshell.v1.RelayInit - (*RelayFrame)(nil), // 143: openshell.v1.RelayFrame - (*RelayOpenResult)(nil), // 144: openshell.v1.RelayOpenResult - (*RelayClose)(nil), // 145: openshell.v1.RelayClose - (*L7RequestSample)(nil), // 146: openshell.v1.L7RequestSample - (*DenialSummary)(nil), // 147: openshell.v1.DenialSummary - (*DenialGroupCount)(nil), // 148: openshell.v1.DenialGroupCount - (*NetworkActivitySummary)(nil), // 149: openshell.v1.NetworkActivitySummary - (*PolicyChunk)(nil), // 150: openshell.v1.PolicyChunk - (*DraftPolicyUpdate)(nil), // 151: openshell.v1.DraftPolicyUpdate - (*SubmitPolicyAnalysisRequest)(nil), // 152: openshell.v1.SubmitPolicyAnalysisRequest - (*SubmitPolicyAnalysisResponse)(nil), // 153: openshell.v1.SubmitPolicyAnalysisResponse - (*GetDraftPolicyRequest)(nil), // 154: openshell.v1.GetDraftPolicyRequest - (*GetDraftPolicyResponse)(nil), // 155: openshell.v1.GetDraftPolicyResponse - (*ApproveDraftChunkRequest)(nil), // 156: openshell.v1.ApproveDraftChunkRequest - (*ApproveDraftChunkResponse)(nil), // 157: openshell.v1.ApproveDraftChunkResponse - (*RejectDraftChunkRequest)(nil), // 158: openshell.v1.RejectDraftChunkRequest - (*RejectDraftChunkResponse)(nil), // 159: openshell.v1.RejectDraftChunkResponse - (*ApproveAllDraftChunksRequest)(nil), // 160: openshell.v1.ApproveAllDraftChunksRequest - (*ApproveAllDraftChunksResponse)(nil), // 161: openshell.v1.ApproveAllDraftChunksResponse - (*EditDraftChunkRequest)(nil), // 162: openshell.v1.EditDraftChunkRequest - (*EditDraftChunkResponse)(nil), // 163: openshell.v1.EditDraftChunkResponse - (*UndoDraftChunkRequest)(nil), // 164: openshell.v1.UndoDraftChunkRequest - (*UndoDraftChunkResponse)(nil), // 165: openshell.v1.UndoDraftChunkResponse - (*ClearDraftChunksRequest)(nil), // 166: openshell.v1.ClearDraftChunksRequest - (*ClearDraftChunksResponse)(nil), // 167: openshell.v1.ClearDraftChunksResponse - (*GetDraftHistoryRequest)(nil), // 168: openshell.v1.GetDraftHistoryRequest - (*DraftHistoryEntry)(nil), // 169: openshell.v1.DraftHistoryEntry - (*GetDraftHistoryResponse)(nil), // 170: openshell.v1.GetDraftHistoryResponse - (*PolicyRevisionPayload)(nil), // 171: openshell.v1.PolicyRevisionPayload - (*DraftChunkPayload)(nil), // 172: openshell.v1.DraftChunkPayload - (*StoredPolicyRevision)(nil), // 173: openshell.v1.StoredPolicyRevision - (*StoredDraftChunk)(nil), // 174: openshell.v1.StoredDraftChunk - (*CreateWorkspaceRequest)(nil), // 175: openshell.v1.CreateWorkspaceRequest - (*CreateWorkspaceResponse)(nil), // 176: openshell.v1.CreateWorkspaceResponse - (*GetWorkspaceRequest)(nil), // 177: openshell.v1.GetWorkspaceRequest - (*GetWorkspaceResponse)(nil), // 178: openshell.v1.GetWorkspaceResponse - (*ListWorkspacesRequest)(nil), // 179: openshell.v1.ListWorkspacesRequest - (*ListWorkspacesResponse)(nil), // 180: openshell.v1.ListWorkspacesResponse - (*DeleteWorkspaceRequest)(nil), // 181: openshell.v1.DeleteWorkspaceRequest - (*DeleteWorkspaceResponse)(nil), // 182: openshell.v1.DeleteWorkspaceResponse - (*WorkspaceMember)(nil), // 183: openshell.v1.WorkspaceMember - (*AddWorkspaceMemberRequest)(nil), // 184: openshell.v1.AddWorkspaceMemberRequest - (*AddWorkspaceMemberResponse)(nil), // 185: openshell.v1.AddWorkspaceMemberResponse - (*RemoveWorkspaceMemberRequest)(nil), // 186: openshell.v1.RemoveWorkspaceMemberRequest - (*RemoveWorkspaceMemberResponse)(nil), // 187: openshell.v1.RemoveWorkspaceMemberResponse - (*ListWorkspaceMembersRequest)(nil), // 188: openshell.v1.ListWorkspaceMembersRequest - (*ListWorkspaceMembersResponse)(nil), // 189: openshell.v1.ListWorkspaceMembersResponse - (*ExtensionServiceCredential)(nil), // 190: openshell.v1.ExtensionServiceCredential - nil, // 191: openshell.v1.SandboxSpec.EnvironmentEntry - nil, // 192: openshell.v1.SandboxTemplate.LabelsEntry - nil, // 193: openshell.v1.SandboxTemplate.AnnotationsEntry - nil, // 194: openshell.v1.SandboxTemplate.EnvironmentEntry - nil, // 195: openshell.v1.PlatformEvent.MetadataEntry - nil, // 196: openshell.v1.CreateSandboxRequest.LabelsEntry - nil, // 197: openshell.v1.CreateSandboxRequest.AnnotationsEntry - nil, // 198: openshell.v1.ExecSandboxRequest.EnvironmentEntry - nil, // 199: openshell.v1.SandboxLogLine.FieldsEntry - nil, // 200: openshell.v1.UpdateProviderRequest.CredentialExpiresAtMsEntry - nil, // 201: openshell.v1.StoredProviderCredentialRefreshState.MaterialEntry - nil, // 202: openshell.v1.StoredProviderCredentialRefreshState.AdditionalOutputKeysEntry - nil, // 203: openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry - nil, // 204: openshell.v1.ProviderProfile.AnnotationsEntry - nil, // 205: openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry - nil, // 206: openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpiresAtMsEntry - nil, // 207: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry - nil, // 208: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry - nil, // 209: openshell.v1.UpdateConfigRequest.AnnotationsEntry - nil, // 210: openshell.v1.UpdateConfigResponse.AnnotationsEntry - nil, // 211: openshell.v1.SandboxPolicyRevision.ProvenanceEntry - nil, // 212: openshell.v1.PolicyRevisionPayload.ProvenanceEntry - nil, // 213: openshell.v1.StoredPolicyRevision.ProvenanceEntry - nil, // 214: openshell.v1.CreateWorkspaceRequest.LabelsEntry - (*datamodelv1.ObjectMeta)(nil), // 215: openshell.datamodel.v1.ObjectMeta - (*sandboxv1.SandboxPolicy)(nil), // 216: openshell.sandbox.v1.SandboxPolicy - (*structpb.Struct)(nil), // 217: google.protobuf.Struct - (*datamodelv1.Provider)(nil), // 218: openshell.datamodel.v1.Provider - (*sandboxv1.NetworkEndpoint)(nil), // 219: openshell.sandbox.v1.NetworkEndpoint - (*sandboxv1.NetworkBinary)(nil), // 220: openshell.sandbox.v1.NetworkBinary - (*sandboxv1.SettingValue)(nil), // 221: openshell.sandbox.v1.SettingValue - (*sandboxv1.NetworkPolicyRule)(nil), // 222: openshell.sandbox.v1.NetworkPolicyRule - (*sandboxv1.L7DenyRule)(nil), // 223: openshell.sandbox.v1.L7DenyRule - (*sandboxv1.L7Rule)(nil), // 224: openshell.sandbox.v1.L7Rule - (*datamodelv1.Workspace)(nil), // 225: openshell.datamodel.v1.Workspace - (*sandboxv1.GetSandboxConfigRequest)(nil), // 226: openshell.sandbox.v1.GetSandboxConfigRequest - (*sandboxv1.GetGatewayConfigRequest)(nil), // 227: openshell.sandbox.v1.GetGatewayConfigRequest - (*sandboxv1.GetSandboxConfigResponse)(nil), // 228: openshell.sandbox.v1.GetSandboxConfigResponse - (*sandboxv1.GetGatewayConfigResponse)(nil), // 229: openshell.sandbox.v1.GetGatewayConfigResponse + (MainProcessState)(0), // 0: openshell.v1.MainProcessState + (SandboxPhase)(0), // 1: openshell.v1.SandboxPhase + (ProviderCredentialRefreshStrategy)(0), // 2: openshell.v1.ProviderCredentialRefreshStrategy + (ProviderProfileCategory)(0), // 3: openshell.v1.ProviderProfileCategory + (PolicyStatus)(0), // 4: openshell.v1.PolicyStatus + (ServiceStatus)(0), // 5: openshell.v1.ServiceStatus + (WorkspaceRole)(0), // 6: openshell.v1.WorkspaceRole + (*IssueSandboxTokenRequest)(nil), // 7: openshell.v1.IssueSandboxTokenRequest + (*IssueSandboxTokenResponse)(nil), // 8: openshell.v1.IssueSandboxTokenResponse + (*RefreshSandboxTokenRequest)(nil), // 9: openshell.v1.RefreshSandboxTokenRequest + (*RefreshSandboxTokenResponse)(nil), // 10: openshell.v1.RefreshSandboxTokenResponse + (*HealthRequest)(nil), // 11: openshell.v1.HealthRequest + (*HealthResponse)(nil), // 12: openshell.v1.HealthResponse + (*GetCurrentUserRequest)(nil), // 13: openshell.v1.GetCurrentUserRequest + (*GetCurrentUserResponse)(nil), // 14: openshell.v1.GetCurrentUserResponse + (*GetGatewayInfoRequest)(nil), // 15: openshell.v1.GetGatewayInfoRequest + (*GetGatewayInfoResponse)(nil), // 16: openshell.v1.GetGatewayInfoResponse + (*ComputeDriverInfo)(nil), // 17: openshell.v1.ComputeDriverInfo + (*ComputeDriverCapabilities)(nil), // 18: openshell.v1.ComputeDriverCapabilities + (*Sandbox)(nil), // 19: openshell.v1.Sandbox + (*SandboxSpec)(nil), // 20: openshell.v1.SandboxSpec + (*MainProcessSpec)(nil), // 21: openshell.v1.MainProcessSpec + (*ResourceRequirements)(nil), // 22: openshell.v1.ResourceRequirements + (*GpuResourceRequirements)(nil), // 23: openshell.v1.GpuResourceRequirements + (*SandboxTemplate)(nil), // 24: openshell.v1.SandboxTemplate + (*SandboxStatus)(nil), // 25: openshell.v1.SandboxStatus + (*MainProcessStatus)(nil), // 26: openshell.v1.MainProcessStatus + (*SandboxCondition)(nil), // 27: openshell.v1.SandboxCondition + (*PlatformEvent)(nil), // 28: openshell.v1.PlatformEvent + (*CreateSandboxRequest)(nil), // 29: openshell.v1.CreateSandboxRequest + (*GetSandboxRequest)(nil), // 30: openshell.v1.GetSandboxRequest + (*ListSandboxesRequest)(nil), // 31: openshell.v1.ListSandboxesRequest + (*ListSandboxProvidersRequest)(nil), // 32: openshell.v1.ListSandboxProvidersRequest + (*AttachSandboxProviderRequest)(nil), // 33: openshell.v1.AttachSandboxProviderRequest + (*DetachSandboxProviderRequest)(nil), // 34: openshell.v1.DetachSandboxProviderRequest + (*DeleteSandboxRequest)(nil), // 35: openshell.v1.DeleteSandboxRequest + (*StopSandboxRequest)(nil), // 36: openshell.v1.StopSandboxRequest + (*StartSandboxRequest)(nil), // 37: openshell.v1.StartSandboxRequest + (*SandboxResponse)(nil), // 38: openshell.v1.SandboxResponse + (*ListSandboxesResponse)(nil), // 39: openshell.v1.ListSandboxesResponse + (*ListSandboxProvidersResponse)(nil), // 40: openshell.v1.ListSandboxProvidersResponse + (*AttachSandboxProviderResponse)(nil), // 41: openshell.v1.AttachSandboxProviderResponse + (*DetachSandboxProviderResponse)(nil), // 42: openshell.v1.DetachSandboxProviderResponse + (*DeleteSandboxResponse)(nil), // 43: openshell.v1.DeleteSandboxResponse + (*CreateSshSessionRequest)(nil), // 44: openshell.v1.CreateSshSessionRequest + (*CreateSshSessionResponse)(nil), // 45: openshell.v1.CreateSshSessionResponse + (*ExposeServiceRequest)(nil), // 46: openshell.v1.ExposeServiceRequest + (*GetServiceRequest)(nil), // 47: openshell.v1.GetServiceRequest + (*ListServicesRequest)(nil), // 48: openshell.v1.ListServicesRequest + (*ListServicesResponse)(nil), // 49: openshell.v1.ListServicesResponse + (*DeleteServiceRequest)(nil), // 50: openshell.v1.DeleteServiceRequest + (*DeleteServiceResponse)(nil), // 51: openshell.v1.DeleteServiceResponse + (*ServiceEndpoint)(nil), // 52: openshell.v1.ServiceEndpoint + (*ServiceEndpointResponse)(nil), // 53: openshell.v1.ServiceEndpointResponse + (*RevokeSshSessionRequest)(nil), // 54: openshell.v1.RevokeSshSessionRequest + (*RevokeSshSessionResponse)(nil), // 55: openshell.v1.RevokeSshSessionResponse + (*ExecSandboxRequest)(nil), // 56: openshell.v1.ExecSandboxRequest + (*ExecSandboxStdout)(nil), // 57: openshell.v1.ExecSandboxStdout + (*ExecSandboxStderr)(nil), // 58: openshell.v1.ExecSandboxStderr + (*ExecSandboxExit)(nil), // 59: openshell.v1.ExecSandboxExit + (*ExecSandboxEvent)(nil), // 60: openshell.v1.ExecSandboxEvent + (*TcpForwardInit)(nil), // 61: openshell.v1.TcpForwardInit + (*TcpForwardFrame)(nil), // 62: openshell.v1.TcpForwardFrame + (*ExecSandboxInput)(nil), // 63: openshell.v1.ExecSandboxInput + (*ExecSandboxWindowResize)(nil), // 64: openshell.v1.ExecSandboxWindowResize + (*SshSession)(nil), // 65: openshell.v1.SshSession + (*WatchSandboxRequest)(nil), // 66: openshell.v1.WatchSandboxRequest + (*SandboxStreamEvent)(nil), // 67: openshell.v1.SandboxStreamEvent + (*SandboxLogLine)(nil), // 68: openshell.v1.SandboxLogLine + (*SandboxStreamWarning)(nil), // 69: openshell.v1.SandboxStreamWarning + (*CreateProviderRequest)(nil), // 70: openshell.v1.CreateProviderRequest + (*GetProviderRequest)(nil), // 71: openshell.v1.GetProviderRequest + (*ListProvidersRequest)(nil), // 72: openshell.v1.ListProvidersRequest + (*UpdateProviderRequest)(nil), // 73: openshell.v1.UpdateProviderRequest + (*DeleteProviderRequest)(nil), // 74: openshell.v1.DeleteProviderRequest + (*ProviderResponse)(nil), // 75: openshell.v1.ProviderResponse + (*ListProvidersResponse)(nil), // 76: openshell.v1.ListProvidersResponse + (*ListProviderProfilesRequest)(nil), // 77: openshell.v1.ListProviderProfilesRequest + (*GetProviderProfileRequest)(nil), // 78: openshell.v1.GetProviderProfileRequest + (*ProviderProfileImportItem)(nil), // 79: openshell.v1.ProviderProfileImportItem + (*ProviderProfileDiagnostic)(nil), // 80: openshell.v1.ProviderProfileDiagnostic + (*ProviderCredentialTokenGrantAudienceOverride)(nil), // 81: openshell.v1.ProviderCredentialTokenGrantAudienceOverride + (*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 + (*GetProviderRefreshStatusRequest)(nil), // 90: openshell.v1.GetProviderRefreshStatusRequest + (*GetProviderRefreshStatusResponse)(nil), // 91: openshell.v1.GetProviderRefreshStatusResponse + (*ConfigureProviderRefreshRequest)(nil), // 92: openshell.v1.ConfigureProviderRefreshRequest + (*ConfigureProviderRefreshResponse)(nil), // 93: openshell.v1.ConfigureProviderRefreshResponse + (*RotateProviderCredentialRequest)(nil), // 94: openshell.v1.RotateProviderCredentialRequest + (*RotateProviderCredentialResponse)(nil), // 95: openshell.v1.RotateProviderCredentialResponse + (*DeleteProviderRefreshRequest)(nil), // 96: openshell.v1.DeleteProviderRefreshRequest + (*DeleteProviderRefreshResponse)(nil), // 97: openshell.v1.DeleteProviderRefreshResponse + (*ProviderProfile)(nil), // 98: openshell.v1.ProviderProfile + (*StoredProviderProfile)(nil), // 99: openshell.v1.StoredProviderProfile + (*ProviderProfileResponse)(nil), // 100: openshell.v1.ProviderProfileResponse + (*ListProviderProfilesResponse)(nil), // 101: openshell.v1.ListProviderProfilesResponse + (*ImportProviderProfilesRequest)(nil), // 102: openshell.v1.ImportProviderProfilesRequest + (*ImportProviderProfilesResponse)(nil), // 103: openshell.v1.ImportProviderProfilesResponse + (*UpdateProviderProfilesRequest)(nil), // 104: openshell.v1.UpdateProviderProfilesRequest + (*UpdateProviderProfilesResponse)(nil), // 105: openshell.v1.UpdateProviderProfilesResponse + (*LintProviderProfilesRequest)(nil), // 106: openshell.v1.LintProviderProfilesRequest + (*LintProviderProfilesResponse)(nil), // 107: openshell.v1.LintProviderProfilesResponse + (*DeleteProviderResponse)(nil), // 108: openshell.v1.DeleteProviderResponse + (*DeleteProviderProfileRequest)(nil), // 109: openshell.v1.DeleteProviderProfileRequest + (*DeleteProviderProfileResponse)(nil), // 110: openshell.v1.DeleteProviderProfileResponse + (*GetSandboxProviderEnvironmentRequest)(nil), // 111: openshell.v1.GetSandboxProviderEnvironmentRequest + (*StaticCredentialEndpointBinding)(nil), // 112: openshell.v1.StaticCredentialEndpointBinding + (*StaticCredentialBinding)(nil), // 113: openshell.v1.StaticCredentialBinding + (*GetSandboxProviderEnvironmentResponse)(nil), // 114: openshell.v1.GetSandboxProviderEnvironmentResponse + (*UpdateConfigRequest)(nil), // 115: openshell.v1.UpdateConfigRequest + (*PolicyMergeOperation)(nil), // 116: openshell.v1.PolicyMergeOperation + (*AddNetworkRule)(nil), // 117: openshell.v1.AddNetworkRule + (*RemoveNetworkEndpoint)(nil), // 118: openshell.v1.RemoveNetworkEndpoint + (*RemoveNetworkRule)(nil), // 119: openshell.v1.RemoveNetworkRule + (*AddDenyRules)(nil), // 120: openshell.v1.AddDenyRules + (*AddAllowRules)(nil), // 121: openshell.v1.AddAllowRules + (*RemoveNetworkBinary)(nil), // 122: openshell.v1.RemoveNetworkBinary + (*UpdateConfigResponse)(nil), // 123: openshell.v1.UpdateConfigResponse + (*GetSandboxPolicyStatusRequest)(nil), // 124: openshell.v1.GetSandboxPolicyStatusRequest + (*GetSandboxPolicyStatusResponse)(nil), // 125: openshell.v1.GetSandboxPolicyStatusResponse + (*ListSandboxPoliciesRequest)(nil), // 126: openshell.v1.ListSandboxPoliciesRequest + (*ListSandboxPoliciesResponse)(nil), // 127: openshell.v1.ListSandboxPoliciesResponse + (*ReportPolicyStatusRequest)(nil), // 128: openshell.v1.ReportPolicyStatusRequest + (*ReportPolicyStatusResponse)(nil), // 129: openshell.v1.ReportPolicyStatusResponse + (*SandboxPolicyRevision)(nil), // 130: openshell.v1.SandboxPolicyRevision + (*GetSandboxLogsRequest)(nil), // 131: openshell.v1.GetSandboxLogsRequest + (*PushSandboxLogsRequest)(nil), // 132: openshell.v1.PushSandboxLogsRequest + (*PushSandboxLogsResponse)(nil), // 133: openshell.v1.PushSandboxLogsResponse + (*GetSandboxLogsResponse)(nil), // 134: openshell.v1.GetSandboxLogsResponse + (*SupervisorMessage)(nil), // 135: openshell.v1.SupervisorMessage + (*GatewayMessage)(nil), // 136: openshell.v1.GatewayMessage + (*SupervisorHello)(nil), // 137: openshell.v1.SupervisorHello + (*SessionAccepted)(nil), // 138: openshell.v1.SessionAccepted + (*SessionRejected)(nil), // 139: openshell.v1.SessionRejected + (*SupervisorHeartbeat)(nil), // 140: openshell.v1.SupervisorHeartbeat + (*GatewayHeartbeat)(nil), // 141: openshell.v1.GatewayHeartbeat + (*MainProcessExit)(nil), // 142: openshell.v1.MainProcessExit + (*MainProcessExitAck)(nil), // 143: openshell.v1.MainProcessExitAck + (*RelayOpen)(nil), // 144: openshell.v1.RelayOpen + (*SshRelayTarget)(nil), // 145: openshell.v1.SshRelayTarget + (*TcpRelayTarget)(nil), // 146: openshell.v1.TcpRelayTarget + (*RelayInit)(nil), // 147: openshell.v1.RelayInit + (*RelayFrame)(nil), // 148: openshell.v1.RelayFrame + (*RelayOpenResult)(nil), // 149: openshell.v1.RelayOpenResult + (*RelayClose)(nil), // 150: openshell.v1.RelayClose + (*L7RequestSample)(nil), // 151: openshell.v1.L7RequestSample + (*DenialSummary)(nil), // 152: openshell.v1.DenialSummary + (*DenialGroupCount)(nil), // 153: openshell.v1.DenialGroupCount + (*NetworkActivitySummary)(nil), // 154: openshell.v1.NetworkActivitySummary + (*PolicyChunk)(nil), // 155: openshell.v1.PolicyChunk + (*DraftPolicyUpdate)(nil), // 156: openshell.v1.DraftPolicyUpdate + (*SubmitPolicyAnalysisRequest)(nil), // 157: openshell.v1.SubmitPolicyAnalysisRequest + (*SubmitPolicyAnalysisResponse)(nil), // 158: openshell.v1.SubmitPolicyAnalysisResponse + (*GetDraftPolicyRequest)(nil), // 159: openshell.v1.GetDraftPolicyRequest + (*GetDraftPolicyResponse)(nil), // 160: openshell.v1.GetDraftPolicyResponse + (*ApproveDraftChunkRequest)(nil), // 161: openshell.v1.ApproveDraftChunkRequest + (*ApproveDraftChunkResponse)(nil), // 162: openshell.v1.ApproveDraftChunkResponse + (*RejectDraftChunkRequest)(nil), // 163: openshell.v1.RejectDraftChunkRequest + (*RejectDraftChunkResponse)(nil), // 164: openshell.v1.RejectDraftChunkResponse + (*ApproveAllDraftChunksRequest)(nil), // 165: openshell.v1.ApproveAllDraftChunksRequest + (*ApproveAllDraftChunksResponse)(nil), // 166: openshell.v1.ApproveAllDraftChunksResponse + (*EditDraftChunkRequest)(nil), // 167: openshell.v1.EditDraftChunkRequest + (*EditDraftChunkResponse)(nil), // 168: openshell.v1.EditDraftChunkResponse + (*UndoDraftChunkRequest)(nil), // 169: openshell.v1.UndoDraftChunkRequest + (*UndoDraftChunkResponse)(nil), // 170: openshell.v1.UndoDraftChunkResponse + (*ClearDraftChunksRequest)(nil), // 171: openshell.v1.ClearDraftChunksRequest + (*ClearDraftChunksResponse)(nil), // 172: openshell.v1.ClearDraftChunksResponse + (*GetDraftHistoryRequest)(nil), // 173: openshell.v1.GetDraftHistoryRequest + (*DraftHistoryEntry)(nil), // 174: openshell.v1.DraftHistoryEntry + (*GetDraftHistoryResponse)(nil), // 175: openshell.v1.GetDraftHistoryResponse + (*PolicyRevisionPayload)(nil), // 176: openshell.v1.PolicyRevisionPayload + (*DraftChunkPayload)(nil), // 177: openshell.v1.DraftChunkPayload + (*StoredPolicyRevision)(nil), // 178: openshell.v1.StoredPolicyRevision + (*StoredDraftChunk)(nil), // 179: openshell.v1.StoredDraftChunk + (*CreateWorkspaceRequest)(nil), // 180: openshell.v1.CreateWorkspaceRequest + (*CreateWorkspaceResponse)(nil), // 181: openshell.v1.CreateWorkspaceResponse + (*GetWorkspaceRequest)(nil), // 182: openshell.v1.GetWorkspaceRequest + (*GetWorkspaceResponse)(nil), // 183: openshell.v1.GetWorkspaceResponse + (*ListWorkspacesRequest)(nil), // 184: openshell.v1.ListWorkspacesRequest + (*ListWorkspacesResponse)(nil), // 185: openshell.v1.ListWorkspacesResponse + (*DeleteWorkspaceRequest)(nil), // 186: openshell.v1.DeleteWorkspaceRequest + (*DeleteWorkspaceResponse)(nil), // 187: openshell.v1.DeleteWorkspaceResponse + (*WorkspaceMember)(nil), // 188: openshell.v1.WorkspaceMember + (*AddWorkspaceMemberRequest)(nil), // 189: openshell.v1.AddWorkspaceMemberRequest + (*AddWorkspaceMemberResponse)(nil), // 190: openshell.v1.AddWorkspaceMemberResponse + (*RemoveWorkspaceMemberRequest)(nil), // 191: openshell.v1.RemoveWorkspaceMemberRequest + (*RemoveWorkspaceMemberResponse)(nil), // 192: openshell.v1.RemoveWorkspaceMemberResponse + (*ListWorkspaceMembersRequest)(nil), // 193: openshell.v1.ListWorkspaceMembersRequest + (*ListWorkspaceMembersResponse)(nil), // 194: openshell.v1.ListWorkspaceMembersResponse + (*ExtensionServiceCredential)(nil), // 195: openshell.v1.ExtensionServiceCredential + nil, // 196: openshell.v1.SandboxSpec.EnvironmentEntry + nil, // 197: openshell.v1.MainProcessSpec.EnvironmentEntry + nil, // 198: openshell.v1.SandboxTemplate.LabelsEntry + nil, // 199: openshell.v1.SandboxTemplate.AnnotationsEntry + nil, // 200: openshell.v1.SandboxTemplate.EnvironmentEntry + nil, // 201: openshell.v1.PlatformEvent.MetadataEntry + nil, // 202: openshell.v1.CreateSandboxRequest.LabelsEntry + nil, // 203: openshell.v1.CreateSandboxRequest.AnnotationsEntry + nil, // 204: openshell.v1.ExecSandboxRequest.EnvironmentEntry + nil, // 205: openshell.v1.SandboxLogLine.FieldsEntry + nil, // 206: openshell.v1.UpdateProviderRequest.CredentialExpiresAtMsEntry + nil, // 207: openshell.v1.StoredProviderCredentialRefreshState.MaterialEntry + nil, // 208: openshell.v1.StoredProviderCredentialRefreshState.AdditionalOutputKeysEntry + nil, // 209: openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry + nil, // 210: openshell.v1.ProviderProfile.AnnotationsEntry + nil, // 211: openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry + nil, // 212: openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpiresAtMsEntry + nil, // 213: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry + nil, // 214: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry + nil, // 215: openshell.v1.UpdateConfigRequest.AnnotationsEntry + nil, // 216: openshell.v1.UpdateConfigResponse.AnnotationsEntry + nil, // 217: openshell.v1.SandboxPolicyRevision.ProvenanceEntry + nil, // 218: openshell.v1.PolicyRevisionPayload.ProvenanceEntry + nil, // 219: openshell.v1.StoredPolicyRevision.ProvenanceEntry + nil, // 220: openshell.v1.CreateWorkspaceRequest.LabelsEntry + (*datamodelv1.ObjectMeta)(nil), // 221: openshell.datamodel.v1.ObjectMeta + (*sandboxv1.SandboxPolicy)(nil), // 222: openshell.sandbox.v1.SandboxPolicy + (*structpb.Struct)(nil), // 223: google.protobuf.Struct + (*datamodelv1.Provider)(nil), // 224: openshell.datamodel.v1.Provider + (*sandboxv1.NetworkEndpoint)(nil), // 225: openshell.sandbox.v1.NetworkEndpoint + (*sandboxv1.NetworkBinary)(nil), // 226: openshell.sandbox.v1.NetworkBinary + (*sandboxv1.SettingValue)(nil), // 227: openshell.sandbox.v1.SettingValue + (*sandboxv1.NetworkPolicyRule)(nil), // 228: openshell.sandbox.v1.NetworkPolicyRule + (*sandboxv1.L7DenyRule)(nil), // 229: openshell.sandbox.v1.L7DenyRule + (*sandboxv1.L7Rule)(nil), // 230: openshell.sandbox.v1.L7Rule + (*datamodelv1.Workspace)(nil), // 231: openshell.datamodel.v1.Workspace + (*sandboxv1.GetSandboxConfigRequest)(nil), // 232: openshell.sandbox.v1.GetSandboxConfigRequest + (*sandboxv1.GetGatewayConfigRequest)(nil), // 233: openshell.sandbox.v1.GetGatewayConfigRequest + (*sandboxv1.GetSandboxConfigResponse)(nil), // 234: openshell.sandbox.v1.GetSandboxConfigResponse + (*sandboxv1.GetGatewayConfigResponse)(nil), // 235: openshell.sandbox.v1.GetGatewayConfigResponse } var file_openshell_proto_depIdxs = []int32{ - 190, // 0: openshell.v1.RefreshSandboxTokenResponse.extension_credentials:type_name -> openshell.v1.ExtensionServiceCredential - 4, // 1: openshell.v1.HealthResponse.status:type_name -> openshell.v1.ServiceStatus - 4, // 2: openshell.v1.GetGatewayInfoResponse.status:type_name -> openshell.v1.ServiceStatus - 16, // 3: openshell.v1.GetGatewayInfoResponse.compute_drivers:type_name -> openshell.v1.ComputeDriverInfo - 17, // 4: openshell.v1.ComputeDriverInfo.capabilities:type_name -> openshell.v1.ComputeDriverCapabilities - 215, // 5: openshell.v1.Sandbox.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 19, // 6: openshell.v1.Sandbox.spec:type_name -> openshell.v1.SandboxSpec - 23, // 7: openshell.v1.Sandbox.status:type_name -> openshell.v1.SandboxStatus - 191, // 8: openshell.v1.SandboxSpec.environment:type_name -> openshell.v1.SandboxSpec.EnvironmentEntry - 22, // 9: openshell.v1.SandboxSpec.template:type_name -> openshell.v1.SandboxTemplate - 216, // 10: openshell.v1.SandboxSpec.policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 20, // 11: openshell.v1.SandboxSpec.resource_requirements:type_name -> openshell.v1.ResourceRequirements - 21, // 12: openshell.v1.ResourceRequirements.gpu:type_name -> openshell.v1.GpuResourceRequirements - 192, // 13: openshell.v1.SandboxTemplate.labels:type_name -> openshell.v1.SandboxTemplate.LabelsEntry - 193, // 14: openshell.v1.SandboxTemplate.annotations:type_name -> openshell.v1.SandboxTemplate.AnnotationsEntry - 194, // 15: openshell.v1.SandboxTemplate.environment:type_name -> openshell.v1.SandboxTemplate.EnvironmentEntry - 217, // 16: openshell.v1.SandboxTemplate.resources:type_name -> google.protobuf.Struct - 217, // 17: openshell.v1.SandboxTemplate.driver_config:type_name -> google.protobuf.Struct - 24, // 18: openshell.v1.SandboxStatus.conditions:type_name -> openshell.v1.SandboxCondition - 0, // 19: openshell.v1.SandboxStatus.phase:type_name -> openshell.v1.SandboxPhase - 195, // 20: openshell.v1.PlatformEvent.metadata:type_name -> openshell.v1.PlatformEvent.MetadataEntry - 19, // 21: openshell.v1.CreateSandboxRequest.spec:type_name -> openshell.v1.SandboxSpec - 196, // 22: openshell.v1.CreateSandboxRequest.labels:type_name -> openshell.v1.CreateSandboxRequest.LabelsEntry - 197, // 23: openshell.v1.CreateSandboxRequest.annotations:type_name -> openshell.v1.CreateSandboxRequest.AnnotationsEntry - 18, // 24: openshell.v1.SandboxResponse.sandbox:type_name -> openshell.v1.Sandbox - 18, // 25: openshell.v1.ListSandboxesResponse.sandboxes:type_name -> openshell.v1.Sandbox - 218, // 26: openshell.v1.ListSandboxProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider - 18, // 27: openshell.v1.AttachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox - 18, // 28: openshell.v1.DetachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox - 50, // 29: openshell.v1.ListServicesResponse.services:type_name -> openshell.v1.ServiceEndpointResponse - 215, // 30: openshell.v1.ServiceEndpoint.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 49, // 31: openshell.v1.ServiceEndpointResponse.endpoint:type_name -> openshell.v1.ServiceEndpoint - 198, // 32: openshell.v1.ExecSandboxRequest.environment:type_name -> openshell.v1.ExecSandboxRequest.EnvironmentEntry - 54, // 33: openshell.v1.ExecSandboxEvent.stdout:type_name -> openshell.v1.ExecSandboxStdout - 55, // 34: openshell.v1.ExecSandboxEvent.stderr:type_name -> openshell.v1.ExecSandboxStderr - 56, // 35: openshell.v1.ExecSandboxEvent.exit:type_name -> openshell.v1.ExecSandboxExit - 140, // 36: openshell.v1.TcpForwardInit.ssh:type_name -> openshell.v1.SshRelayTarget - 141, // 37: openshell.v1.TcpForwardInit.tcp:type_name -> openshell.v1.TcpRelayTarget - 58, // 38: openshell.v1.TcpForwardFrame.init:type_name -> openshell.v1.TcpForwardInit - 53, // 39: openshell.v1.ExecSandboxInput.start:type_name -> openshell.v1.ExecSandboxRequest - 61, // 40: openshell.v1.ExecSandboxInput.resize:type_name -> openshell.v1.ExecSandboxWindowResize - 215, // 41: openshell.v1.SshSession.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 18, // 42: openshell.v1.SandboxStreamEvent.sandbox:type_name -> openshell.v1.Sandbox - 65, // 43: openshell.v1.SandboxStreamEvent.log:type_name -> openshell.v1.SandboxLogLine - 25, // 44: openshell.v1.SandboxStreamEvent.event:type_name -> openshell.v1.PlatformEvent - 66, // 45: openshell.v1.SandboxStreamEvent.warning:type_name -> openshell.v1.SandboxStreamWarning - 151, // 46: openshell.v1.SandboxStreamEvent.draft_policy_update:type_name -> openshell.v1.DraftPolicyUpdate - 199, // 47: openshell.v1.SandboxLogLine.fields:type_name -> openshell.v1.SandboxLogLine.FieldsEntry - 218, // 48: openshell.v1.CreateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider - 218, // 49: openshell.v1.UpdateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider - 200, // 50: openshell.v1.UpdateProviderRequest.credential_expires_at_ms:type_name -> openshell.v1.UpdateProviderRequest.CredentialExpiresAtMsEntry - 218, // 51: openshell.v1.ProviderResponse.provider:type_name -> openshell.datamodel.v1.Provider - 218, // 52: openshell.v1.ListProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider - 95, // 53: openshell.v1.ProviderProfileImportItem.profile:type_name -> openshell.v1.ProviderProfile - 78, // 54: openshell.v1.ProviderCredentialTokenGrant.audience_overrides:type_name -> openshell.v1.ProviderCredentialTokenGrantAudienceOverride - 83, // 55: openshell.v1.ProviderProfileCredential.refresh:type_name -> openshell.v1.ProviderCredentialRefresh - 79, // 56: openshell.v1.ProviderProfileCredential.token_grant:type_name -> openshell.v1.ProviderCredentialTokenGrant - 1, // 57: openshell.v1.ProviderCredentialRefresh.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 81, // 58: openshell.v1.ProviderCredentialRefresh.material:type_name -> openshell.v1.ProviderCredentialRefreshMaterial - 82, // 59: openshell.v1.ProviderCredentialRefresh.additional_outputs:type_name -> openshell.v1.ProviderCredentialRefreshOutput - 1, // 60: openshell.v1.ProviderCredentialRefreshStatus.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 215, // 61: openshell.v1.StoredProviderCredentialRefreshState.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 1, // 62: openshell.v1.StoredProviderCredentialRefreshState.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 201, // 63: openshell.v1.StoredProviderCredentialRefreshState.material:type_name -> openshell.v1.StoredProviderCredentialRefreshState.MaterialEntry - 202, // 64: openshell.v1.StoredProviderCredentialRefreshState.additional_output_keys:type_name -> openshell.v1.StoredProviderCredentialRefreshState.AdditionalOutputKeysEntry - 84, // 65: openshell.v1.GetProviderRefreshStatusResponse.credentials:type_name -> openshell.v1.ProviderCredentialRefreshStatus - 1, // 66: openshell.v1.ConfigureProviderRefreshRequest.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 203, // 67: openshell.v1.ConfigureProviderRefreshRequest.material:type_name -> openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry - 84, // 68: openshell.v1.ConfigureProviderRefreshResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus - 84, // 69: openshell.v1.RotateProviderCredentialResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus - 2, // 70: openshell.v1.ProviderProfile.category:type_name -> openshell.v1.ProviderProfileCategory - 80, // 71: openshell.v1.ProviderProfile.credentials:type_name -> openshell.v1.ProviderProfileCredential - 219, // 72: openshell.v1.ProviderProfile.endpoints:type_name -> openshell.sandbox.v1.NetworkEndpoint - 220, // 73: openshell.v1.ProviderProfile.binaries:type_name -> openshell.sandbox.v1.NetworkBinary - 85, // 74: openshell.v1.ProviderProfile.discovery:type_name -> openshell.v1.ProviderProfileDiscovery - 204, // 75: openshell.v1.ProviderProfile.annotations:type_name -> openshell.v1.ProviderProfile.AnnotationsEntry - 215, // 76: openshell.v1.StoredProviderProfile.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 95, // 77: openshell.v1.StoredProviderProfile.profile:type_name -> openshell.v1.ProviderProfile - 95, // 78: openshell.v1.ProviderProfileResponse.profile:type_name -> openshell.v1.ProviderProfile - 95, // 79: openshell.v1.ListProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile - 76, // 80: openshell.v1.ImportProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem - 77, // 81: openshell.v1.ImportProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic - 95, // 82: openshell.v1.ImportProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile - 76, // 83: openshell.v1.UpdateProviderProfilesRequest.profile:type_name -> openshell.v1.ProviderProfileImportItem - 77, // 84: openshell.v1.UpdateProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic - 95, // 85: openshell.v1.UpdateProviderProfilesResponse.profile:type_name -> openshell.v1.ProviderProfile - 76, // 86: openshell.v1.LintProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem - 77, // 87: openshell.v1.LintProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic - 109, // 88: openshell.v1.StaticCredentialBinding.endpoints:type_name -> openshell.v1.StaticCredentialEndpointBinding - 205, // 89: openshell.v1.GetSandboxProviderEnvironmentResponse.environment:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry - 206, // 90: openshell.v1.GetSandboxProviderEnvironmentResponse.credential_expires_at_ms:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpiresAtMsEntry - 207, // 91: openshell.v1.GetSandboxProviderEnvironmentResponse.dynamic_credentials:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry - 208, // 92: openshell.v1.GetSandboxProviderEnvironmentResponse.static_credential_bindings:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry - 216, // 93: openshell.v1.UpdateConfigRequest.policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 221, // 94: openshell.v1.UpdateConfigRequest.setting_value:type_name -> openshell.sandbox.v1.SettingValue - 113, // 95: openshell.v1.UpdateConfigRequest.merge_operations:type_name -> openshell.v1.PolicyMergeOperation - 209, // 96: openshell.v1.UpdateConfigRequest.annotations:type_name -> openshell.v1.UpdateConfigRequest.AnnotationsEntry - 114, // 97: openshell.v1.PolicyMergeOperation.add_rule:type_name -> openshell.v1.AddNetworkRule - 115, // 98: openshell.v1.PolicyMergeOperation.remove_endpoint:type_name -> openshell.v1.RemoveNetworkEndpoint - 116, // 99: openshell.v1.PolicyMergeOperation.remove_rule:type_name -> openshell.v1.RemoveNetworkRule - 117, // 100: openshell.v1.PolicyMergeOperation.add_deny_rules:type_name -> openshell.v1.AddDenyRules - 118, // 101: openshell.v1.PolicyMergeOperation.add_allow_rules:type_name -> openshell.v1.AddAllowRules - 119, // 102: openshell.v1.PolicyMergeOperation.remove_binary:type_name -> openshell.v1.RemoveNetworkBinary - 222, // 103: openshell.v1.AddNetworkRule.rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 223, // 104: openshell.v1.AddDenyRules.deny_rules:type_name -> openshell.sandbox.v1.L7DenyRule - 224, // 105: openshell.v1.AddAllowRules.rules:type_name -> openshell.sandbox.v1.L7Rule - 210, // 106: openshell.v1.UpdateConfigResponse.annotations:type_name -> openshell.v1.UpdateConfigResponse.AnnotationsEntry - 127, // 107: openshell.v1.GetSandboxPolicyStatusResponse.revision:type_name -> openshell.v1.SandboxPolicyRevision - 127, // 108: openshell.v1.ListSandboxPoliciesResponse.revisions:type_name -> openshell.v1.SandboxPolicyRevision - 3, // 109: openshell.v1.ReportPolicyStatusRequest.status:type_name -> openshell.v1.PolicyStatus - 3, // 110: openshell.v1.SandboxPolicyRevision.status:type_name -> openshell.v1.PolicyStatus - 216, // 111: openshell.v1.SandboxPolicyRevision.policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 211, // 112: openshell.v1.SandboxPolicyRevision.provenance:type_name -> openshell.v1.SandboxPolicyRevision.ProvenanceEntry - 65, // 113: openshell.v1.PushSandboxLogsRequest.logs:type_name -> openshell.v1.SandboxLogLine - 65, // 114: openshell.v1.GetSandboxLogsResponse.logs:type_name -> openshell.v1.SandboxLogLine - 134, // 115: openshell.v1.SupervisorMessage.hello:type_name -> openshell.v1.SupervisorHello - 137, // 116: openshell.v1.SupervisorMessage.heartbeat:type_name -> openshell.v1.SupervisorHeartbeat - 144, // 117: openshell.v1.SupervisorMessage.relay_open_result:type_name -> openshell.v1.RelayOpenResult - 145, // 118: openshell.v1.SupervisorMessage.relay_close:type_name -> openshell.v1.RelayClose - 135, // 119: openshell.v1.GatewayMessage.session_accepted:type_name -> openshell.v1.SessionAccepted - 136, // 120: openshell.v1.GatewayMessage.session_rejected:type_name -> openshell.v1.SessionRejected - 138, // 121: openshell.v1.GatewayMessage.heartbeat:type_name -> openshell.v1.GatewayHeartbeat - 139, // 122: openshell.v1.GatewayMessage.relay_open:type_name -> openshell.v1.RelayOpen - 145, // 123: openshell.v1.GatewayMessage.relay_close:type_name -> openshell.v1.RelayClose - 140, // 124: openshell.v1.RelayOpen.ssh:type_name -> openshell.v1.SshRelayTarget - 141, // 125: openshell.v1.RelayOpen.tcp:type_name -> openshell.v1.TcpRelayTarget - 142, // 126: openshell.v1.RelayFrame.init:type_name -> openshell.v1.RelayInit - 146, // 127: openshell.v1.DenialSummary.l7_request_samples:type_name -> openshell.v1.L7RequestSample - 148, // 128: openshell.v1.NetworkActivitySummary.denials_by_group:type_name -> openshell.v1.DenialGroupCount - 222, // 129: openshell.v1.PolicyChunk.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 147, // 130: openshell.v1.SubmitPolicyAnalysisRequest.summaries:type_name -> openshell.v1.DenialSummary - 150, // 131: openshell.v1.SubmitPolicyAnalysisRequest.proposed_chunks:type_name -> openshell.v1.PolicyChunk - 149, // 132: openshell.v1.SubmitPolicyAnalysisRequest.network_activity_summaries:type_name -> openshell.v1.NetworkActivitySummary - 150, // 133: openshell.v1.GetDraftPolicyResponse.chunks:type_name -> openshell.v1.PolicyChunk - 222, // 134: openshell.v1.EditDraftChunkRequest.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 169, // 135: openshell.v1.GetDraftHistoryResponse.entries:type_name -> openshell.v1.DraftHistoryEntry - 216, // 136: openshell.v1.PolicyRevisionPayload.policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 212, // 137: openshell.v1.PolicyRevisionPayload.provenance:type_name -> openshell.v1.PolicyRevisionPayload.ProvenanceEntry - 222, // 138: openshell.v1.DraftChunkPayload.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 213, // 139: openshell.v1.StoredPolicyRevision.provenance:type_name -> openshell.v1.StoredPolicyRevision.ProvenanceEntry - 214, // 140: openshell.v1.CreateWorkspaceRequest.labels:type_name -> openshell.v1.CreateWorkspaceRequest.LabelsEntry - 225, // 141: openshell.v1.CreateWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace - 225, // 142: openshell.v1.GetWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace - 225, // 143: openshell.v1.ListWorkspacesResponse.workspaces:type_name -> openshell.datamodel.v1.Workspace - 215, // 144: openshell.v1.WorkspaceMember.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 5, // 145: openshell.v1.WorkspaceMember.role:type_name -> openshell.v1.WorkspaceRole - 5, // 146: openshell.v1.AddWorkspaceMemberRequest.role:type_name -> openshell.v1.WorkspaceRole - 183, // 147: openshell.v1.AddWorkspaceMemberResponse.member:type_name -> openshell.v1.WorkspaceMember - 183, // 148: openshell.v1.ListWorkspaceMembersResponse.members:type_name -> openshell.v1.WorkspaceMember - 80, // 149: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry.value:type_name -> openshell.v1.ProviderProfileCredential - 110, // 150: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry.value:type_name -> openshell.v1.StaticCredentialBinding - 10, // 151: openshell.v1.OpenShell.Health:input_type -> openshell.v1.HealthRequest - 12, // 152: openshell.v1.OpenShell.GetCurrentUser:input_type -> openshell.v1.GetCurrentUserRequest - 14, // 153: openshell.v1.OpenShell.GetGatewayInfo:input_type -> openshell.v1.GetGatewayInfoRequest - 26, // 154: openshell.v1.OpenShell.CreateSandbox:input_type -> openshell.v1.CreateSandboxRequest - 27, // 155: openshell.v1.OpenShell.GetSandbox:input_type -> openshell.v1.GetSandboxRequest - 28, // 156: openshell.v1.OpenShell.ListSandboxes:input_type -> openshell.v1.ListSandboxesRequest - 29, // 157: openshell.v1.OpenShell.ListSandboxProviders:input_type -> openshell.v1.ListSandboxProvidersRequest - 30, // 158: openshell.v1.OpenShell.AttachSandboxProvider:input_type -> openshell.v1.AttachSandboxProviderRequest - 31, // 159: openshell.v1.OpenShell.DetachSandboxProvider:input_type -> openshell.v1.DetachSandboxProviderRequest - 32, // 160: openshell.v1.OpenShell.DeleteSandbox:input_type -> openshell.v1.DeleteSandboxRequest - 33, // 161: openshell.v1.OpenShell.StopSandbox:input_type -> openshell.v1.StopSandboxRequest - 34, // 162: openshell.v1.OpenShell.StartSandbox:input_type -> openshell.v1.StartSandboxRequest - 41, // 163: openshell.v1.OpenShell.CreateSshSession:input_type -> openshell.v1.CreateSshSessionRequest - 43, // 164: openshell.v1.OpenShell.ExposeService:input_type -> openshell.v1.ExposeServiceRequest - 44, // 165: openshell.v1.OpenShell.GetService:input_type -> openshell.v1.GetServiceRequest - 45, // 166: openshell.v1.OpenShell.ListServices:input_type -> openshell.v1.ListServicesRequest - 47, // 167: openshell.v1.OpenShell.DeleteService:input_type -> openshell.v1.DeleteServiceRequest - 51, // 168: openshell.v1.OpenShell.RevokeSshSession:input_type -> openshell.v1.RevokeSshSessionRequest - 53, // 169: openshell.v1.OpenShell.ExecSandbox:input_type -> openshell.v1.ExecSandboxRequest - 59, // 170: openshell.v1.OpenShell.ForwardTcp:input_type -> openshell.v1.TcpForwardFrame - 60, // 171: openshell.v1.OpenShell.ExecSandboxInteractive:input_type -> openshell.v1.ExecSandboxInput - 67, // 172: openshell.v1.OpenShell.CreateProvider:input_type -> openshell.v1.CreateProviderRequest - 68, // 173: openshell.v1.OpenShell.GetProvider:input_type -> openshell.v1.GetProviderRequest - 69, // 174: openshell.v1.OpenShell.ListProviders:input_type -> openshell.v1.ListProvidersRequest - 74, // 175: openshell.v1.OpenShell.ListProviderProfiles:input_type -> openshell.v1.ListProviderProfilesRequest - 75, // 176: openshell.v1.OpenShell.GetProviderProfile:input_type -> openshell.v1.GetProviderProfileRequest - 99, // 177: openshell.v1.OpenShell.ImportProviderProfiles:input_type -> openshell.v1.ImportProviderProfilesRequest - 101, // 178: openshell.v1.OpenShell.UpdateProviderProfiles:input_type -> openshell.v1.UpdateProviderProfilesRequest - 103, // 179: openshell.v1.OpenShell.LintProviderProfiles:input_type -> openshell.v1.LintProviderProfilesRequest - 70, // 180: openshell.v1.OpenShell.UpdateProvider:input_type -> openshell.v1.UpdateProviderRequest - 87, // 181: openshell.v1.OpenShell.GetProviderRefreshStatus:input_type -> openshell.v1.GetProviderRefreshStatusRequest - 89, // 182: openshell.v1.OpenShell.ConfigureProviderRefresh:input_type -> openshell.v1.ConfigureProviderRefreshRequest - 91, // 183: openshell.v1.OpenShell.RotateProviderCredential:input_type -> openshell.v1.RotateProviderCredentialRequest - 93, // 184: openshell.v1.OpenShell.DeleteProviderRefresh:input_type -> openshell.v1.DeleteProviderRefreshRequest - 71, // 185: openshell.v1.OpenShell.DeleteProvider:input_type -> openshell.v1.DeleteProviderRequest - 106, // 186: openshell.v1.OpenShell.DeleteProviderProfile:input_type -> openshell.v1.DeleteProviderProfileRequest - 226, // 187: openshell.v1.OpenShell.GetSandboxConfig:input_type -> openshell.sandbox.v1.GetSandboxConfigRequest - 227, // 188: openshell.v1.OpenShell.GetGatewayConfig:input_type -> openshell.sandbox.v1.GetGatewayConfigRequest - 112, // 189: openshell.v1.OpenShell.UpdateConfig:input_type -> openshell.v1.UpdateConfigRequest - 121, // 190: openshell.v1.OpenShell.GetSandboxPolicyStatus:input_type -> openshell.v1.GetSandboxPolicyStatusRequest - 123, // 191: openshell.v1.OpenShell.ListSandboxPolicies:input_type -> openshell.v1.ListSandboxPoliciesRequest - 125, // 192: openshell.v1.OpenShell.ReportPolicyStatus:input_type -> openshell.v1.ReportPolicyStatusRequest - 108, // 193: openshell.v1.OpenShell.GetSandboxProviderEnvironment:input_type -> openshell.v1.GetSandboxProviderEnvironmentRequest - 128, // 194: openshell.v1.OpenShell.GetSandboxLogs:input_type -> openshell.v1.GetSandboxLogsRequest - 129, // 195: openshell.v1.OpenShell.PushSandboxLogs:input_type -> openshell.v1.PushSandboxLogsRequest - 132, // 196: openshell.v1.OpenShell.ConnectSupervisor:input_type -> openshell.v1.SupervisorMessage - 143, // 197: openshell.v1.OpenShell.RelayStream:input_type -> openshell.v1.RelayFrame - 63, // 198: openshell.v1.OpenShell.WatchSandbox:input_type -> openshell.v1.WatchSandboxRequest - 152, // 199: openshell.v1.OpenShell.SubmitPolicyAnalysis:input_type -> openshell.v1.SubmitPolicyAnalysisRequest - 154, // 200: openshell.v1.OpenShell.GetDraftPolicy:input_type -> openshell.v1.GetDraftPolicyRequest - 156, // 201: openshell.v1.OpenShell.ApproveDraftChunk:input_type -> openshell.v1.ApproveDraftChunkRequest - 158, // 202: openshell.v1.OpenShell.RejectDraftChunk:input_type -> openshell.v1.RejectDraftChunkRequest - 160, // 203: openshell.v1.OpenShell.ApproveAllDraftChunks:input_type -> openshell.v1.ApproveAllDraftChunksRequest - 162, // 204: openshell.v1.OpenShell.EditDraftChunk:input_type -> openshell.v1.EditDraftChunkRequest - 164, // 205: openshell.v1.OpenShell.UndoDraftChunk:input_type -> openshell.v1.UndoDraftChunkRequest - 166, // 206: openshell.v1.OpenShell.ClearDraftChunks:input_type -> openshell.v1.ClearDraftChunksRequest - 168, // 207: openshell.v1.OpenShell.GetDraftHistory:input_type -> openshell.v1.GetDraftHistoryRequest - 6, // 208: openshell.v1.OpenShell.IssueSandboxToken:input_type -> openshell.v1.IssueSandboxTokenRequest - 8, // 209: openshell.v1.OpenShell.RefreshSandboxToken:input_type -> openshell.v1.RefreshSandboxTokenRequest - 175, // 210: openshell.v1.OpenShell.CreateWorkspace:input_type -> openshell.v1.CreateWorkspaceRequest - 177, // 211: openshell.v1.OpenShell.GetWorkspace:input_type -> openshell.v1.GetWorkspaceRequest - 179, // 212: openshell.v1.OpenShell.ListWorkspaces:input_type -> openshell.v1.ListWorkspacesRequest - 181, // 213: openshell.v1.OpenShell.DeleteWorkspace:input_type -> openshell.v1.DeleteWorkspaceRequest - 184, // 214: openshell.v1.OpenShell.AddWorkspaceMember:input_type -> openshell.v1.AddWorkspaceMemberRequest - 186, // 215: openshell.v1.OpenShell.RemoveWorkspaceMember:input_type -> openshell.v1.RemoveWorkspaceMemberRequest - 188, // 216: openshell.v1.OpenShell.ListWorkspaceMembers:input_type -> openshell.v1.ListWorkspaceMembersRequest - 11, // 217: openshell.v1.OpenShell.Health:output_type -> openshell.v1.HealthResponse - 13, // 218: openshell.v1.OpenShell.GetCurrentUser:output_type -> openshell.v1.GetCurrentUserResponse - 15, // 219: openshell.v1.OpenShell.GetGatewayInfo:output_type -> openshell.v1.GetGatewayInfoResponse - 35, // 220: openshell.v1.OpenShell.CreateSandbox:output_type -> openshell.v1.SandboxResponse - 35, // 221: openshell.v1.OpenShell.GetSandbox:output_type -> openshell.v1.SandboxResponse - 36, // 222: openshell.v1.OpenShell.ListSandboxes:output_type -> openshell.v1.ListSandboxesResponse - 37, // 223: openshell.v1.OpenShell.ListSandboxProviders:output_type -> openshell.v1.ListSandboxProvidersResponse - 38, // 224: openshell.v1.OpenShell.AttachSandboxProvider:output_type -> openshell.v1.AttachSandboxProviderResponse - 39, // 225: openshell.v1.OpenShell.DetachSandboxProvider:output_type -> openshell.v1.DetachSandboxProviderResponse - 40, // 226: openshell.v1.OpenShell.DeleteSandbox:output_type -> openshell.v1.DeleteSandboxResponse - 35, // 227: openshell.v1.OpenShell.StopSandbox:output_type -> openshell.v1.SandboxResponse - 35, // 228: openshell.v1.OpenShell.StartSandbox:output_type -> openshell.v1.SandboxResponse - 42, // 229: openshell.v1.OpenShell.CreateSshSession:output_type -> openshell.v1.CreateSshSessionResponse - 50, // 230: openshell.v1.OpenShell.ExposeService:output_type -> openshell.v1.ServiceEndpointResponse - 50, // 231: openshell.v1.OpenShell.GetService:output_type -> openshell.v1.ServiceEndpointResponse - 46, // 232: openshell.v1.OpenShell.ListServices:output_type -> openshell.v1.ListServicesResponse - 48, // 233: openshell.v1.OpenShell.DeleteService:output_type -> openshell.v1.DeleteServiceResponse - 52, // 234: openshell.v1.OpenShell.RevokeSshSession:output_type -> openshell.v1.RevokeSshSessionResponse - 57, // 235: openshell.v1.OpenShell.ExecSandbox:output_type -> openshell.v1.ExecSandboxEvent - 59, // 236: openshell.v1.OpenShell.ForwardTcp:output_type -> openshell.v1.TcpForwardFrame - 57, // 237: openshell.v1.OpenShell.ExecSandboxInteractive:output_type -> openshell.v1.ExecSandboxEvent - 72, // 238: openshell.v1.OpenShell.CreateProvider:output_type -> openshell.v1.ProviderResponse - 72, // 239: openshell.v1.OpenShell.GetProvider:output_type -> openshell.v1.ProviderResponse - 73, // 240: openshell.v1.OpenShell.ListProviders:output_type -> openshell.v1.ListProvidersResponse - 98, // 241: openshell.v1.OpenShell.ListProviderProfiles:output_type -> openshell.v1.ListProviderProfilesResponse - 97, // 242: openshell.v1.OpenShell.GetProviderProfile:output_type -> openshell.v1.ProviderProfileResponse - 100, // 243: openshell.v1.OpenShell.ImportProviderProfiles:output_type -> openshell.v1.ImportProviderProfilesResponse - 102, // 244: openshell.v1.OpenShell.UpdateProviderProfiles:output_type -> openshell.v1.UpdateProviderProfilesResponse - 104, // 245: openshell.v1.OpenShell.LintProviderProfiles:output_type -> openshell.v1.LintProviderProfilesResponse - 72, // 246: openshell.v1.OpenShell.UpdateProvider:output_type -> openshell.v1.ProviderResponse - 88, // 247: openshell.v1.OpenShell.GetProviderRefreshStatus:output_type -> openshell.v1.GetProviderRefreshStatusResponse - 90, // 248: openshell.v1.OpenShell.ConfigureProviderRefresh:output_type -> openshell.v1.ConfigureProviderRefreshResponse - 92, // 249: openshell.v1.OpenShell.RotateProviderCredential:output_type -> openshell.v1.RotateProviderCredentialResponse - 94, // 250: openshell.v1.OpenShell.DeleteProviderRefresh:output_type -> openshell.v1.DeleteProviderRefreshResponse - 105, // 251: openshell.v1.OpenShell.DeleteProvider:output_type -> openshell.v1.DeleteProviderResponse - 107, // 252: openshell.v1.OpenShell.DeleteProviderProfile:output_type -> openshell.v1.DeleteProviderProfileResponse - 228, // 253: openshell.v1.OpenShell.GetSandboxConfig:output_type -> openshell.sandbox.v1.GetSandboxConfigResponse - 229, // 254: openshell.v1.OpenShell.GetGatewayConfig:output_type -> openshell.sandbox.v1.GetGatewayConfigResponse - 120, // 255: openshell.v1.OpenShell.UpdateConfig:output_type -> openshell.v1.UpdateConfigResponse - 122, // 256: openshell.v1.OpenShell.GetSandboxPolicyStatus:output_type -> openshell.v1.GetSandboxPolicyStatusResponse - 124, // 257: openshell.v1.OpenShell.ListSandboxPolicies:output_type -> openshell.v1.ListSandboxPoliciesResponse - 126, // 258: openshell.v1.OpenShell.ReportPolicyStatus:output_type -> openshell.v1.ReportPolicyStatusResponse - 111, // 259: openshell.v1.OpenShell.GetSandboxProviderEnvironment:output_type -> openshell.v1.GetSandboxProviderEnvironmentResponse - 131, // 260: openshell.v1.OpenShell.GetSandboxLogs:output_type -> openshell.v1.GetSandboxLogsResponse - 130, // 261: openshell.v1.OpenShell.PushSandboxLogs:output_type -> openshell.v1.PushSandboxLogsResponse - 133, // 262: openshell.v1.OpenShell.ConnectSupervisor:output_type -> openshell.v1.GatewayMessage - 143, // 263: openshell.v1.OpenShell.RelayStream:output_type -> openshell.v1.RelayFrame - 64, // 264: openshell.v1.OpenShell.WatchSandbox:output_type -> openshell.v1.SandboxStreamEvent - 153, // 265: openshell.v1.OpenShell.SubmitPolicyAnalysis:output_type -> openshell.v1.SubmitPolicyAnalysisResponse - 155, // 266: openshell.v1.OpenShell.GetDraftPolicy:output_type -> openshell.v1.GetDraftPolicyResponse - 157, // 267: openshell.v1.OpenShell.ApproveDraftChunk:output_type -> openshell.v1.ApproveDraftChunkResponse - 159, // 268: openshell.v1.OpenShell.RejectDraftChunk:output_type -> openshell.v1.RejectDraftChunkResponse - 161, // 269: openshell.v1.OpenShell.ApproveAllDraftChunks:output_type -> openshell.v1.ApproveAllDraftChunksResponse - 163, // 270: openshell.v1.OpenShell.EditDraftChunk:output_type -> openshell.v1.EditDraftChunkResponse - 165, // 271: openshell.v1.OpenShell.UndoDraftChunk:output_type -> openshell.v1.UndoDraftChunkResponse - 167, // 272: openshell.v1.OpenShell.ClearDraftChunks:output_type -> openshell.v1.ClearDraftChunksResponse - 170, // 273: openshell.v1.OpenShell.GetDraftHistory:output_type -> openshell.v1.GetDraftHistoryResponse - 7, // 274: openshell.v1.OpenShell.IssueSandboxToken:output_type -> openshell.v1.IssueSandboxTokenResponse - 9, // 275: openshell.v1.OpenShell.RefreshSandboxToken:output_type -> openshell.v1.RefreshSandboxTokenResponse - 176, // 276: openshell.v1.OpenShell.CreateWorkspace:output_type -> openshell.v1.CreateWorkspaceResponse - 178, // 277: openshell.v1.OpenShell.GetWorkspace:output_type -> openshell.v1.GetWorkspaceResponse - 180, // 278: openshell.v1.OpenShell.ListWorkspaces:output_type -> openshell.v1.ListWorkspacesResponse - 182, // 279: openshell.v1.OpenShell.DeleteWorkspace:output_type -> openshell.v1.DeleteWorkspaceResponse - 185, // 280: openshell.v1.OpenShell.AddWorkspaceMember:output_type -> openshell.v1.AddWorkspaceMemberResponse - 187, // 281: openshell.v1.OpenShell.RemoveWorkspaceMember:output_type -> openshell.v1.RemoveWorkspaceMemberResponse - 189, // 282: openshell.v1.OpenShell.ListWorkspaceMembers:output_type -> openshell.v1.ListWorkspaceMembersResponse - 217, // [217:283] is the sub-list for method output_type - 151, // [151:217] is the sub-list for method input_type - 151, // [151:151] is the sub-list for extension type_name - 151, // [151:151] is the sub-list for extension extendee - 0, // [0:151] is the sub-list for field type_name + 195, // 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 + 17, // 3: openshell.v1.GetGatewayInfoResponse.compute_drivers:type_name -> openshell.v1.ComputeDriverInfo + 18, // 4: openshell.v1.ComputeDriverInfo.capabilities:type_name -> openshell.v1.ComputeDriverCapabilities + 221, // 5: openshell.v1.Sandbox.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 20, // 6: openshell.v1.Sandbox.spec:type_name -> openshell.v1.SandboxSpec + 25, // 7: openshell.v1.Sandbox.status:type_name -> openshell.v1.SandboxStatus + 196, // 8: openshell.v1.SandboxSpec.environment:type_name -> openshell.v1.SandboxSpec.EnvironmentEntry + 24, // 9: openshell.v1.SandboxSpec.template:type_name -> openshell.v1.SandboxTemplate + 222, // 10: openshell.v1.SandboxSpec.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 22, // 11: openshell.v1.SandboxSpec.resource_requirements:type_name -> openshell.v1.ResourceRequirements + 21, // 12: openshell.v1.SandboxSpec.main_process:type_name -> openshell.v1.MainProcessSpec + 197, // 13: openshell.v1.MainProcessSpec.environment:type_name -> openshell.v1.MainProcessSpec.EnvironmentEntry + 23, // 14: openshell.v1.ResourceRequirements.gpu:type_name -> openshell.v1.GpuResourceRequirements + 198, // 15: openshell.v1.SandboxTemplate.labels:type_name -> openshell.v1.SandboxTemplate.LabelsEntry + 199, // 16: openshell.v1.SandboxTemplate.annotations:type_name -> openshell.v1.SandboxTemplate.AnnotationsEntry + 200, // 17: openshell.v1.SandboxTemplate.environment:type_name -> openshell.v1.SandboxTemplate.EnvironmentEntry + 223, // 18: openshell.v1.SandboxTemplate.resources:type_name -> google.protobuf.Struct + 223, // 19: openshell.v1.SandboxTemplate.driver_config:type_name -> google.protobuf.Struct + 27, // 20: openshell.v1.SandboxStatus.conditions:type_name -> openshell.v1.SandboxCondition + 1, // 21: openshell.v1.SandboxStatus.phase:type_name -> openshell.v1.SandboxPhase + 26, // 22: openshell.v1.SandboxStatus.main_process:type_name -> openshell.v1.MainProcessStatus + 0, // 23: openshell.v1.MainProcessStatus.state:type_name -> openshell.v1.MainProcessState + 201, // 24: openshell.v1.PlatformEvent.metadata:type_name -> openshell.v1.PlatformEvent.MetadataEntry + 20, // 25: openshell.v1.CreateSandboxRequest.spec:type_name -> openshell.v1.SandboxSpec + 202, // 26: openshell.v1.CreateSandboxRequest.labels:type_name -> openshell.v1.CreateSandboxRequest.LabelsEntry + 203, // 27: openshell.v1.CreateSandboxRequest.annotations:type_name -> openshell.v1.CreateSandboxRequest.AnnotationsEntry + 19, // 28: openshell.v1.SandboxResponse.sandbox:type_name -> openshell.v1.Sandbox + 19, // 29: openshell.v1.ListSandboxesResponse.sandboxes:type_name -> openshell.v1.Sandbox + 224, // 30: openshell.v1.ListSandboxProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider + 19, // 31: openshell.v1.AttachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox + 19, // 32: openshell.v1.DetachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox + 53, // 33: openshell.v1.ListServicesResponse.services:type_name -> openshell.v1.ServiceEndpointResponse + 221, // 34: openshell.v1.ServiceEndpoint.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 52, // 35: openshell.v1.ServiceEndpointResponse.endpoint:type_name -> openshell.v1.ServiceEndpoint + 204, // 36: openshell.v1.ExecSandboxRequest.environment:type_name -> openshell.v1.ExecSandboxRequest.EnvironmentEntry + 57, // 37: openshell.v1.ExecSandboxEvent.stdout:type_name -> openshell.v1.ExecSandboxStdout + 58, // 38: openshell.v1.ExecSandboxEvent.stderr:type_name -> openshell.v1.ExecSandboxStderr + 59, // 39: openshell.v1.ExecSandboxEvent.exit:type_name -> openshell.v1.ExecSandboxExit + 145, // 40: openshell.v1.TcpForwardInit.ssh:type_name -> openshell.v1.SshRelayTarget + 146, // 41: openshell.v1.TcpForwardInit.tcp:type_name -> openshell.v1.TcpRelayTarget + 61, // 42: openshell.v1.TcpForwardFrame.init:type_name -> openshell.v1.TcpForwardInit + 56, // 43: openshell.v1.ExecSandboxInput.start:type_name -> openshell.v1.ExecSandboxRequest + 64, // 44: openshell.v1.ExecSandboxInput.resize:type_name -> openshell.v1.ExecSandboxWindowResize + 221, // 45: openshell.v1.SshSession.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 19, // 46: openshell.v1.SandboxStreamEvent.sandbox:type_name -> openshell.v1.Sandbox + 68, // 47: openshell.v1.SandboxStreamEvent.log:type_name -> openshell.v1.SandboxLogLine + 28, // 48: openshell.v1.SandboxStreamEvent.event:type_name -> openshell.v1.PlatformEvent + 69, // 49: openshell.v1.SandboxStreamEvent.warning:type_name -> openshell.v1.SandboxStreamWarning + 156, // 50: openshell.v1.SandboxStreamEvent.draft_policy_update:type_name -> openshell.v1.DraftPolicyUpdate + 205, // 51: openshell.v1.SandboxLogLine.fields:type_name -> openshell.v1.SandboxLogLine.FieldsEntry + 224, // 52: openshell.v1.CreateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider + 224, // 53: openshell.v1.UpdateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider + 206, // 54: openshell.v1.UpdateProviderRequest.credential_expires_at_ms:type_name -> openshell.v1.UpdateProviderRequest.CredentialExpiresAtMsEntry + 224, // 55: openshell.v1.ProviderResponse.provider:type_name -> openshell.datamodel.v1.Provider + 224, // 56: openshell.v1.ListProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider + 98, // 57: openshell.v1.ProviderProfileImportItem.profile:type_name -> openshell.v1.ProviderProfile + 81, // 58: openshell.v1.ProviderCredentialTokenGrant.audience_overrides:type_name -> openshell.v1.ProviderCredentialTokenGrantAudienceOverride + 86, // 59: openshell.v1.ProviderProfileCredential.refresh:type_name -> openshell.v1.ProviderCredentialRefresh + 82, // 60: openshell.v1.ProviderProfileCredential.token_grant:type_name -> openshell.v1.ProviderCredentialTokenGrant + 2, // 61: openshell.v1.ProviderCredentialRefresh.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 84, // 62: openshell.v1.ProviderCredentialRefresh.material:type_name -> openshell.v1.ProviderCredentialRefreshMaterial + 85, // 63: openshell.v1.ProviderCredentialRefresh.additional_outputs:type_name -> openshell.v1.ProviderCredentialRefreshOutput + 2, // 64: openshell.v1.ProviderCredentialRefreshStatus.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 221, // 65: openshell.v1.StoredProviderCredentialRefreshState.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 2, // 66: openshell.v1.StoredProviderCredentialRefreshState.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 207, // 67: openshell.v1.StoredProviderCredentialRefreshState.material:type_name -> openshell.v1.StoredProviderCredentialRefreshState.MaterialEntry + 208, // 68: openshell.v1.StoredProviderCredentialRefreshState.additional_output_keys:type_name -> openshell.v1.StoredProviderCredentialRefreshState.AdditionalOutputKeysEntry + 87, // 69: openshell.v1.GetProviderRefreshStatusResponse.credentials:type_name -> openshell.v1.ProviderCredentialRefreshStatus + 2, // 70: openshell.v1.ConfigureProviderRefreshRequest.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 209, // 71: openshell.v1.ConfigureProviderRefreshRequest.material:type_name -> openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry + 87, // 72: openshell.v1.ConfigureProviderRefreshResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus + 87, // 73: openshell.v1.RotateProviderCredentialResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus + 3, // 74: openshell.v1.ProviderProfile.category:type_name -> openshell.v1.ProviderProfileCategory + 83, // 75: openshell.v1.ProviderProfile.credentials:type_name -> openshell.v1.ProviderProfileCredential + 225, // 76: openshell.v1.ProviderProfile.endpoints:type_name -> openshell.sandbox.v1.NetworkEndpoint + 226, // 77: openshell.v1.ProviderProfile.binaries:type_name -> openshell.sandbox.v1.NetworkBinary + 88, // 78: openshell.v1.ProviderProfile.discovery:type_name -> openshell.v1.ProviderProfileDiscovery + 210, // 79: openshell.v1.ProviderProfile.annotations:type_name -> openshell.v1.ProviderProfile.AnnotationsEntry + 221, // 80: openshell.v1.StoredProviderProfile.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 98, // 81: openshell.v1.StoredProviderProfile.profile:type_name -> openshell.v1.ProviderProfile + 98, // 82: openshell.v1.ProviderProfileResponse.profile:type_name -> openshell.v1.ProviderProfile + 98, // 83: openshell.v1.ListProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile + 79, // 84: openshell.v1.ImportProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem + 80, // 85: openshell.v1.ImportProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic + 98, // 86: openshell.v1.ImportProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile + 79, // 87: openshell.v1.UpdateProviderProfilesRequest.profile:type_name -> openshell.v1.ProviderProfileImportItem + 80, // 88: openshell.v1.UpdateProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic + 98, // 89: openshell.v1.UpdateProviderProfilesResponse.profile:type_name -> openshell.v1.ProviderProfile + 79, // 90: openshell.v1.LintProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem + 80, // 91: openshell.v1.LintProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic + 112, // 92: openshell.v1.StaticCredentialBinding.endpoints:type_name -> openshell.v1.StaticCredentialEndpointBinding + 211, // 93: openshell.v1.GetSandboxProviderEnvironmentResponse.environment:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry + 212, // 94: openshell.v1.GetSandboxProviderEnvironmentResponse.credential_expires_at_ms:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpiresAtMsEntry + 213, // 95: openshell.v1.GetSandboxProviderEnvironmentResponse.dynamic_credentials:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry + 214, // 96: openshell.v1.GetSandboxProviderEnvironmentResponse.static_credential_bindings:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry + 222, // 97: openshell.v1.UpdateConfigRequest.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 227, // 98: openshell.v1.UpdateConfigRequest.setting_value:type_name -> openshell.sandbox.v1.SettingValue + 116, // 99: openshell.v1.UpdateConfigRequest.merge_operations:type_name -> openshell.v1.PolicyMergeOperation + 215, // 100: openshell.v1.UpdateConfigRequest.annotations:type_name -> openshell.v1.UpdateConfigRequest.AnnotationsEntry + 117, // 101: openshell.v1.PolicyMergeOperation.add_rule:type_name -> openshell.v1.AddNetworkRule + 118, // 102: openshell.v1.PolicyMergeOperation.remove_endpoint:type_name -> openshell.v1.RemoveNetworkEndpoint + 119, // 103: openshell.v1.PolicyMergeOperation.remove_rule:type_name -> openshell.v1.RemoveNetworkRule + 120, // 104: openshell.v1.PolicyMergeOperation.add_deny_rules:type_name -> openshell.v1.AddDenyRules + 121, // 105: openshell.v1.PolicyMergeOperation.add_allow_rules:type_name -> openshell.v1.AddAllowRules + 122, // 106: openshell.v1.PolicyMergeOperation.remove_binary:type_name -> openshell.v1.RemoveNetworkBinary + 228, // 107: openshell.v1.AddNetworkRule.rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 229, // 108: openshell.v1.AddDenyRules.deny_rules:type_name -> openshell.sandbox.v1.L7DenyRule + 230, // 109: openshell.v1.AddAllowRules.rules:type_name -> openshell.sandbox.v1.L7Rule + 216, // 110: openshell.v1.UpdateConfigResponse.annotations:type_name -> openshell.v1.UpdateConfigResponse.AnnotationsEntry + 130, // 111: openshell.v1.GetSandboxPolicyStatusResponse.revision:type_name -> openshell.v1.SandboxPolicyRevision + 130, // 112: openshell.v1.ListSandboxPoliciesResponse.revisions:type_name -> openshell.v1.SandboxPolicyRevision + 4, // 113: openshell.v1.ReportPolicyStatusRequest.status:type_name -> openshell.v1.PolicyStatus + 4, // 114: openshell.v1.SandboxPolicyRevision.status:type_name -> openshell.v1.PolicyStatus + 222, // 115: openshell.v1.SandboxPolicyRevision.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 217, // 116: openshell.v1.SandboxPolicyRevision.provenance:type_name -> openshell.v1.SandboxPolicyRevision.ProvenanceEntry + 68, // 117: openshell.v1.PushSandboxLogsRequest.logs:type_name -> openshell.v1.SandboxLogLine + 68, // 118: openshell.v1.GetSandboxLogsResponse.logs:type_name -> openshell.v1.SandboxLogLine + 137, // 119: openshell.v1.SupervisorMessage.hello:type_name -> openshell.v1.SupervisorHello + 140, // 120: openshell.v1.SupervisorMessage.heartbeat:type_name -> openshell.v1.SupervisorHeartbeat + 149, // 121: openshell.v1.SupervisorMessage.relay_open_result:type_name -> openshell.v1.RelayOpenResult + 150, // 122: openshell.v1.SupervisorMessage.relay_close:type_name -> openshell.v1.RelayClose + 142, // 123: openshell.v1.SupervisorMessage.main_process_exit:type_name -> openshell.v1.MainProcessExit + 138, // 124: openshell.v1.GatewayMessage.session_accepted:type_name -> openshell.v1.SessionAccepted + 139, // 125: openshell.v1.GatewayMessage.session_rejected:type_name -> openshell.v1.SessionRejected + 141, // 126: openshell.v1.GatewayMessage.heartbeat:type_name -> openshell.v1.GatewayHeartbeat + 144, // 127: openshell.v1.GatewayMessage.relay_open:type_name -> openshell.v1.RelayOpen + 150, // 128: openshell.v1.GatewayMessage.relay_close:type_name -> openshell.v1.RelayClose + 143, // 129: openshell.v1.GatewayMessage.main_process_exit_ack:type_name -> openshell.v1.MainProcessExitAck + 145, // 130: openshell.v1.RelayOpen.ssh:type_name -> openshell.v1.SshRelayTarget + 146, // 131: openshell.v1.RelayOpen.tcp:type_name -> openshell.v1.TcpRelayTarget + 147, // 132: openshell.v1.RelayFrame.init:type_name -> openshell.v1.RelayInit + 151, // 133: openshell.v1.DenialSummary.l7_request_samples:type_name -> openshell.v1.L7RequestSample + 153, // 134: openshell.v1.NetworkActivitySummary.denials_by_group:type_name -> openshell.v1.DenialGroupCount + 228, // 135: openshell.v1.PolicyChunk.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 152, // 136: openshell.v1.SubmitPolicyAnalysisRequest.summaries:type_name -> openshell.v1.DenialSummary + 155, // 137: openshell.v1.SubmitPolicyAnalysisRequest.proposed_chunks:type_name -> openshell.v1.PolicyChunk + 154, // 138: openshell.v1.SubmitPolicyAnalysisRequest.network_activity_summaries:type_name -> openshell.v1.NetworkActivitySummary + 155, // 139: openshell.v1.GetDraftPolicyResponse.chunks:type_name -> openshell.v1.PolicyChunk + 228, // 140: openshell.v1.EditDraftChunkRequest.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 174, // 141: openshell.v1.GetDraftHistoryResponse.entries:type_name -> openshell.v1.DraftHistoryEntry + 222, // 142: openshell.v1.PolicyRevisionPayload.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 218, // 143: openshell.v1.PolicyRevisionPayload.provenance:type_name -> openshell.v1.PolicyRevisionPayload.ProvenanceEntry + 228, // 144: openshell.v1.DraftChunkPayload.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 219, // 145: openshell.v1.StoredPolicyRevision.provenance:type_name -> openshell.v1.StoredPolicyRevision.ProvenanceEntry + 220, // 146: openshell.v1.CreateWorkspaceRequest.labels:type_name -> openshell.v1.CreateWorkspaceRequest.LabelsEntry + 231, // 147: openshell.v1.CreateWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace + 231, // 148: openshell.v1.GetWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace + 231, // 149: openshell.v1.ListWorkspacesResponse.workspaces:type_name -> openshell.datamodel.v1.Workspace + 221, // 150: openshell.v1.WorkspaceMember.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 6, // 151: openshell.v1.WorkspaceMember.role:type_name -> openshell.v1.WorkspaceRole + 6, // 152: openshell.v1.AddWorkspaceMemberRequest.role:type_name -> openshell.v1.WorkspaceRole + 188, // 153: openshell.v1.AddWorkspaceMemberResponse.member:type_name -> openshell.v1.WorkspaceMember + 188, // 154: openshell.v1.ListWorkspaceMembersResponse.members:type_name -> openshell.v1.WorkspaceMember + 83, // 155: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry.value:type_name -> openshell.v1.ProviderProfileCredential + 113, // 156: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry.value:type_name -> openshell.v1.StaticCredentialBinding + 11, // 157: openshell.v1.OpenShell.Health:input_type -> openshell.v1.HealthRequest + 13, // 158: openshell.v1.OpenShell.GetCurrentUser:input_type -> openshell.v1.GetCurrentUserRequest + 15, // 159: openshell.v1.OpenShell.GetGatewayInfo:input_type -> openshell.v1.GetGatewayInfoRequest + 29, // 160: openshell.v1.OpenShell.CreateSandbox:input_type -> openshell.v1.CreateSandboxRequest + 30, // 161: openshell.v1.OpenShell.GetSandbox:input_type -> openshell.v1.GetSandboxRequest + 31, // 162: openshell.v1.OpenShell.ListSandboxes:input_type -> openshell.v1.ListSandboxesRequest + 32, // 163: openshell.v1.OpenShell.ListSandboxProviders:input_type -> openshell.v1.ListSandboxProvidersRequest + 33, // 164: openshell.v1.OpenShell.AttachSandboxProvider:input_type -> openshell.v1.AttachSandboxProviderRequest + 34, // 165: openshell.v1.OpenShell.DetachSandboxProvider:input_type -> openshell.v1.DetachSandboxProviderRequest + 35, // 166: openshell.v1.OpenShell.DeleteSandbox:input_type -> openshell.v1.DeleteSandboxRequest + 36, // 167: openshell.v1.OpenShell.StopSandbox:input_type -> openshell.v1.StopSandboxRequest + 37, // 168: openshell.v1.OpenShell.StartSandbox:input_type -> openshell.v1.StartSandboxRequest + 44, // 169: openshell.v1.OpenShell.CreateSshSession:input_type -> openshell.v1.CreateSshSessionRequest + 46, // 170: openshell.v1.OpenShell.ExposeService:input_type -> openshell.v1.ExposeServiceRequest + 47, // 171: openshell.v1.OpenShell.GetService:input_type -> openshell.v1.GetServiceRequest + 48, // 172: openshell.v1.OpenShell.ListServices:input_type -> openshell.v1.ListServicesRequest + 50, // 173: openshell.v1.OpenShell.DeleteService:input_type -> openshell.v1.DeleteServiceRequest + 54, // 174: openshell.v1.OpenShell.RevokeSshSession:input_type -> openshell.v1.RevokeSshSessionRequest + 56, // 175: openshell.v1.OpenShell.ExecSandbox:input_type -> openshell.v1.ExecSandboxRequest + 62, // 176: openshell.v1.OpenShell.ForwardTcp:input_type -> openshell.v1.TcpForwardFrame + 63, // 177: openshell.v1.OpenShell.ExecSandboxInteractive:input_type -> openshell.v1.ExecSandboxInput + 70, // 178: openshell.v1.OpenShell.CreateProvider:input_type -> openshell.v1.CreateProviderRequest + 71, // 179: openshell.v1.OpenShell.GetProvider:input_type -> openshell.v1.GetProviderRequest + 72, // 180: openshell.v1.OpenShell.ListProviders:input_type -> openshell.v1.ListProvidersRequest + 77, // 181: openshell.v1.OpenShell.ListProviderProfiles:input_type -> openshell.v1.ListProviderProfilesRequest + 78, // 182: openshell.v1.OpenShell.GetProviderProfile:input_type -> openshell.v1.GetProviderProfileRequest + 102, // 183: openshell.v1.OpenShell.ImportProviderProfiles:input_type -> openshell.v1.ImportProviderProfilesRequest + 104, // 184: openshell.v1.OpenShell.UpdateProviderProfiles:input_type -> openshell.v1.UpdateProviderProfilesRequest + 106, // 185: openshell.v1.OpenShell.LintProviderProfiles:input_type -> openshell.v1.LintProviderProfilesRequest + 73, // 186: openshell.v1.OpenShell.UpdateProvider:input_type -> openshell.v1.UpdateProviderRequest + 90, // 187: openshell.v1.OpenShell.GetProviderRefreshStatus:input_type -> openshell.v1.GetProviderRefreshStatusRequest + 92, // 188: openshell.v1.OpenShell.ConfigureProviderRefresh:input_type -> openshell.v1.ConfigureProviderRefreshRequest + 94, // 189: openshell.v1.OpenShell.RotateProviderCredential:input_type -> openshell.v1.RotateProviderCredentialRequest + 96, // 190: openshell.v1.OpenShell.DeleteProviderRefresh:input_type -> openshell.v1.DeleteProviderRefreshRequest + 74, // 191: openshell.v1.OpenShell.DeleteProvider:input_type -> openshell.v1.DeleteProviderRequest + 109, // 192: openshell.v1.OpenShell.DeleteProviderProfile:input_type -> openshell.v1.DeleteProviderProfileRequest + 232, // 193: openshell.v1.OpenShell.GetSandboxConfig:input_type -> openshell.sandbox.v1.GetSandboxConfigRequest + 233, // 194: openshell.v1.OpenShell.GetGatewayConfig:input_type -> openshell.sandbox.v1.GetGatewayConfigRequest + 115, // 195: openshell.v1.OpenShell.UpdateConfig:input_type -> openshell.v1.UpdateConfigRequest + 124, // 196: openshell.v1.OpenShell.GetSandboxPolicyStatus:input_type -> openshell.v1.GetSandboxPolicyStatusRequest + 126, // 197: openshell.v1.OpenShell.ListSandboxPolicies:input_type -> openshell.v1.ListSandboxPoliciesRequest + 128, // 198: openshell.v1.OpenShell.ReportPolicyStatus:input_type -> openshell.v1.ReportPolicyStatusRequest + 111, // 199: openshell.v1.OpenShell.GetSandboxProviderEnvironment:input_type -> openshell.v1.GetSandboxProviderEnvironmentRequest + 131, // 200: openshell.v1.OpenShell.GetSandboxLogs:input_type -> openshell.v1.GetSandboxLogsRequest + 132, // 201: openshell.v1.OpenShell.PushSandboxLogs:input_type -> openshell.v1.PushSandboxLogsRequest + 135, // 202: openshell.v1.OpenShell.ConnectSupervisor:input_type -> openshell.v1.SupervisorMessage + 148, // 203: openshell.v1.OpenShell.RelayStream:input_type -> openshell.v1.RelayFrame + 66, // 204: openshell.v1.OpenShell.WatchSandbox:input_type -> openshell.v1.WatchSandboxRequest + 157, // 205: openshell.v1.OpenShell.SubmitPolicyAnalysis:input_type -> openshell.v1.SubmitPolicyAnalysisRequest + 159, // 206: openshell.v1.OpenShell.GetDraftPolicy:input_type -> openshell.v1.GetDraftPolicyRequest + 161, // 207: openshell.v1.OpenShell.ApproveDraftChunk:input_type -> openshell.v1.ApproveDraftChunkRequest + 163, // 208: openshell.v1.OpenShell.RejectDraftChunk:input_type -> openshell.v1.RejectDraftChunkRequest + 165, // 209: openshell.v1.OpenShell.ApproveAllDraftChunks:input_type -> openshell.v1.ApproveAllDraftChunksRequest + 167, // 210: openshell.v1.OpenShell.EditDraftChunk:input_type -> openshell.v1.EditDraftChunkRequest + 169, // 211: openshell.v1.OpenShell.UndoDraftChunk:input_type -> openshell.v1.UndoDraftChunkRequest + 171, // 212: openshell.v1.OpenShell.ClearDraftChunks:input_type -> openshell.v1.ClearDraftChunksRequest + 173, // 213: openshell.v1.OpenShell.GetDraftHistory:input_type -> openshell.v1.GetDraftHistoryRequest + 7, // 214: openshell.v1.OpenShell.IssueSandboxToken:input_type -> openshell.v1.IssueSandboxTokenRequest + 9, // 215: openshell.v1.OpenShell.RefreshSandboxToken:input_type -> openshell.v1.RefreshSandboxTokenRequest + 180, // 216: openshell.v1.OpenShell.CreateWorkspace:input_type -> openshell.v1.CreateWorkspaceRequest + 182, // 217: openshell.v1.OpenShell.GetWorkspace:input_type -> openshell.v1.GetWorkspaceRequest + 184, // 218: openshell.v1.OpenShell.ListWorkspaces:input_type -> openshell.v1.ListWorkspacesRequest + 186, // 219: openshell.v1.OpenShell.DeleteWorkspace:input_type -> openshell.v1.DeleteWorkspaceRequest + 189, // 220: openshell.v1.OpenShell.AddWorkspaceMember:input_type -> openshell.v1.AddWorkspaceMemberRequest + 191, // 221: openshell.v1.OpenShell.RemoveWorkspaceMember:input_type -> openshell.v1.RemoveWorkspaceMemberRequest + 193, // 222: openshell.v1.OpenShell.ListWorkspaceMembers:input_type -> openshell.v1.ListWorkspaceMembersRequest + 12, // 223: openshell.v1.OpenShell.Health:output_type -> openshell.v1.HealthResponse + 14, // 224: openshell.v1.OpenShell.GetCurrentUser:output_type -> openshell.v1.GetCurrentUserResponse + 16, // 225: openshell.v1.OpenShell.GetGatewayInfo:output_type -> openshell.v1.GetGatewayInfoResponse + 38, // 226: openshell.v1.OpenShell.CreateSandbox:output_type -> openshell.v1.SandboxResponse + 38, // 227: openshell.v1.OpenShell.GetSandbox:output_type -> openshell.v1.SandboxResponse + 39, // 228: openshell.v1.OpenShell.ListSandboxes:output_type -> openshell.v1.ListSandboxesResponse + 40, // 229: openshell.v1.OpenShell.ListSandboxProviders:output_type -> openshell.v1.ListSandboxProvidersResponse + 41, // 230: openshell.v1.OpenShell.AttachSandboxProvider:output_type -> openshell.v1.AttachSandboxProviderResponse + 42, // 231: openshell.v1.OpenShell.DetachSandboxProvider:output_type -> openshell.v1.DetachSandboxProviderResponse + 43, // 232: openshell.v1.OpenShell.DeleteSandbox:output_type -> openshell.v1.DeleteSandboxResponse + 38, // 233: openshell.v1.OpenShell.StopSandbox:output_type -> openshell.v1.SandboxResponse + 38, // 234: openshell.v1.OpenShell.StartSandbox:output_type -> openshell.v1.SandboxResponse + 45, // 235: openshell.v1.OpenShell.CreateSshSession:output_type -> openshell.v1.CreateSshSessionResponse + 53, // 236: openshell.v1.OpenShell.ExposeService:output_type -> openshell.v1.ServiceEndpointResponse + 53, // 237: openshell.v1.OpenShell.GetService:output_type -> openshell.v1.ServiceEndpointResponse + 49, // 238: openshell.v1.OpenShell.ListServices:output_type -> openshell.v1.ListServicesResponse + 51, // 239: openshell.v1.OpenShell.DeleteService:output_type -> openshell.v1.DeleteServiceResponse + 55, // 240: openshell.v1.OpenShell.RevokeSshSession:output_type -> openshell.v1.RevokeSshSessionResponse + 60, // 241: openshell.v1.OpenShell.ExecSandbox:output_type -> openshell.v1.ExecSandboxEvent + 62, // 242: openshell.v1.OpenShell.ForwardTcp:output_type -> openshell.v1.TcpForwardFrame + 60, // 243: openshell.v1.OpenShell.ExecSandboxInteractive:output_type -> openshell.v1.ExecSandboxEvent + 75, // 244: openshell.v1.OpenShell.CreateProvider:output_type -> openshell.v1.ProviderResponse + 75, // 245: openshell.v1.OpenShell.GetProvider:output_type -> openshell.v1.ProviderResponse + 76, // 246: openshell.v1.OpenShell.ListProviders:output_type -> openshell.v1.ListProvidersResponse + 101, // 247: openshell.v1.OpenShell.ListProviderProfiles:output_type -> openshell.v1.ListProviderProfilesResponse + 100, // 248: openshell.v1.OpenShell.GetProviderProfile:output_type -> openshell.v1.ProviderProfileResponse + 103, // 249: openshell.v1.OpenShell.ImportProviderProfiles:output_type -> openshell.v1.ImportProviderProfilesResponse + 105, // 250: openshell.v1.OpenShell.UpdateProviderProfiles:output_type -> openshell.v1.UpdateProviderProfilesResponse + 107, // 251: openshell.v1.OpenShell.LintProviderProfiles:output_type -> openshell.v1.LintProviderProfilesResponse + 75, // 252: openshell.v1.OpenShell.UpdateProvider:output_type -> openshell.v1.ProviderResponse + 91, // 253: openshell.v1.OpenShell.GetProviderRefreshStatus:output_type -> openshell.v1.GetProviderRefreshStatusResponse + 93, // 254: openshell.v1.OpenShell.ConfigureProviderRefresh:output_type -> openshell.v1.ConfigureProviderRefreshResponse + 95, // 255: openshell.v1.OpenShell.RotateProviderCredential:output_type -> openshell.v1.RotateProviderCredentialResponse + 97, // 256: openshell.v1.OpenShell.DeleteProviderRefresh:output_type -> openshell.v1.DeleteProviderRefreshResponse + 108, // 257: openshell.v1.OpenShell.DeleteProvider:output_type -> openshell.v1.DeleteProviderResponse + 110, // 258: openshell.v1.OpenShell.DeleteProviderProfile:output_type -> openshell.v1.DeleteProviderProfileResponse + 234, // 259: openshell.v1.OpenShell.GetSandboxConfig:output_type -> openshell.sandbox.v1.GetSandboxConfigResponse + 235, // 260: openshell.v1.OpenShell.GetGatewayConfig:output_type -> openshell.sandbox.v1.GetGatewayConfigResponse + 123, // 261: openshell.v1.OpenShell.UpdateConfig:output_type -> openshell.v1.UpdateConfigResponse + 125, // 262: openshell.v1.OpenShell.GetSandboxPolicyStatus:output_type -> openshell.v1.GetSandboxPolicyStatusResponse + 127, // 263: openshell.v1.OpenShell.ListSandboxPolicies:output_type -> openshell.v1.ListSandboxPoliciesResponse + 129, // 264: openshell.v1.OpenShell.ReportPolicyStatus:output_type -> openshell.v1.ReportPolicyStatusResponse + 114, // 265: openshell.v1.OpenShell.GetSandboxProviderEnvironment:output_type -> openshell.v1.GetSandboxProviderEnvironmentResponse + 134, // 266: openshell.v1.OpenShell.GetSandboxLogs:output_type -> openshell.v1.GetSandboxLogsResponse + 133, // 267: openshell.v1.OpenShell.PushSandboxLogs:output_type -> openshell.v1.PushSandboxLogsResponse + 136, // 268: openshell.v1.OpenShell.ConnectSupervisor:output_type -> openshell.v1.GatewayMessage + 148, // 269: openshell.v1.OpenShell.RelayStream:output_type -> openshell.v1.RelayFrame + 67, // 270: openshell.v1.OpenShell.WatchSandbox:output_type -> openshell.v1.SandboxStreamEvent + 158, // 271: openshell.v1.OpenShell.SubmitPolicyAnalysis:output_type -> openshell.v1.SubmitPolicyAnalysisResponse + 160, // 272: openshell.v1.OpenShell.GetDraftPolicy:output_type -> openshell.v1.GetDraftPolicyResponse + 162, // 273: openshell.v1.OpenShell.ApproveDraftChunk:output_type -> openshell.v1.ApproveDraftChunkResponse + 164, // 274: openshell.v1.OpenShell.RejectDraftChunk:output_type -> openshell.v1.RejectDraftChunkResponse + 166, // 275: openshell.v1.OpenShell.ApproveAllDraftChunks:output_type -> openshell.v1.ApproveAllDraftChunksResponse + 168, // 276: openshell.v1.OpenShell.EditDraftChunk:output_type -> openshell.v1.EditDraftChunkResponse + 170, // 277: openshell.v1.OpenShell.UndoDraftChunk:output_type -> openshell.v1.UndoDraftChunkResponse + 172, // 278: openshell.v1.OpenShell.ClearDraftChunks:output_type -> openshell.v1.ClearDraftChunksResponse + 175, // 279: openshell.v1.OpenShell.GetDraftHistory:output_type -> openshell.v1.GetDraftHistoryResponse + 8, // 280: openshell.v1.OpenShell.IssueSandboxToken:output_type -> openshell.v1.IssueSandboxTokenResponse + 10, // 281: openshell.v1.OpenShell.RefreshSandboxToken:output_type -> openshell.v1.RefreshSandboxTokenResponse + 181, // 282: openshell.v1.OpenShell.CreateWorkspace:output_type -> openshell.v1.CreateWorkspaceResponse + 183, // 283: openshell.v1.OpenShell.GetWorkspace:output_type -> openshell.v1.GetWorkspaceResponse + 185, // 284: openshell.v1.OpenShell.ListWorkspaces:output_type -> openshell.v1.ListWorkspacesResponse + 187, // 285: openshell.v1.OpenShell.DeleteWorkspace:output_type -> openshell.v1.DeleteWorkspaceResponse + 190, // 286: openshell.v1.OpenShell.AddWorkspaceMember:output_type -> openshell.v1.AddWorkspaceMemberResponse + 192, // 287: openshell.v1.OpenShell.RemoveWorkspaceMember:output_type -> openshell.v1.RemoveWorkspaceMemberResponse + 194, // 288: openshell.v1.OpenShell.ListWorkspaceMembers:output_type -> openshell.v1.ListWorkspaceMembersResponse + 223, // [223:289] is the sub-list for method output_type + 157, // [157:223] is the sub-list for method input_type + 157, // [157:157] is the sub-list for extension type_name + 157, // [157:157] is the sub-list for extension extendee + 0, // [0:157] is the sub-list for field type_name } func init() { file_openshell_proto_init() } @@ -14815,35 +15275,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[51].OneofWrappers = []any{ + file_openshell_proto_msgTypes[17].OneofWrappers = []any{} + file_openshell_proto_msgTypes[19].OneofWrappers = []any{} + file_openshell_proto_msgTypes[53].OneofWrappers = []any{ (*ExecSandboxEvent_Stdout)(nil), (*ExecSandboxEvent_Stderr)(nil), (*ExecSandboxEvent_Exit)(nil), } - file_openshell_proto_msgTypes[52].OneofWrappers = []any{ + file_openshell_proto_msgTypes[54].OneofWrappers = []any{ (*TcpForwardInit_Ssh)(nil), (*TcpForwardInit_Tcp)(nil), } - file_openshell_proto_msgTypes[53].OneofWrappers = []any{ + file_openshell_proto_msgTypes[55].OneofWrappers = []any{ (*TcpForwardFrame_Init)(nil), (*TcpForwardFrame_Data)(nil), } - file_openshell_proto_msgTypes[54].OneofWrappers = []any{ + file_openshell_proto_msgTypes[56].OneofWrappers = []any{ (*ExecSandboxInput_Start)(nil), (*ExecSandboxInput_Stdin)(nil), (*ExecSandboxInput_Resize)(nil), } - file_openshell_proto_msgTypes[58].OneofWrappers = []any{ + file_openshell_proto_msgTypes[60].OneofWrappers = []any{ (*SandboxStreamEvent_Sandbox)(nil), (*SandboxStreamEvent_Log)(nil), (*SandboxStreamEvent_Event)(nil), (*SandboxStreamEvent_Warning)(nil), (*SandboxStreamEvent_DraftPolicyUpdate)(nil), } - file_openshell_proto_msgTypes[83].OneofWrappers = []any{} - file_openshell_proto_msgTypes[107].OneofWrappers = []any{ + file_openshell_proto_msgTypes[85].OneofWrappers = []any{} + file_openshell_proto_msgTypes[109].OneofWrappers = []any{ (*PolicyMergeOperation_AddRule)(nil), (*PolicyMergeOperation_RemoveEndpoint)(nil), (*PolicyMergeOperation_RemoveRule)(nil), @@ -14851,36 +15312,39 @@ func file_openshell_proto_init() { (*PolicyMergeOperation_AddAllowRules)(nil), (*PolicyMergeOperation_RemoveBinary)(nil), } - file_openshell_proto_msgTypes[126].OneofWrappers = []any{ + file_openshell_proto_msgTypes[128].OneofWrappers = []any{ (*SupervisorMessage_Hello)(nil), (*SupervisorMessage_Heartbeat)(nil), (*SupervisorMessage_RelayOpenResult)(nil), (*SupervisorMessage_RelayClose)(nil), + (*SupervisorMessage_MainProcessExit)(nil), } - file_openshell_proto_msgTypes[127].OneofWrappers = []any{ + file_openshell_proto_msgTypes[129].OneofWrappers = []any{ (*GatewayMessage_SessionAccepted)(nil), (*GatewayMessage_SessionRejected)(nil), (*GatewayMessage_Heartbeat)(nil), (*GatewayMessage_RelayOpen)(nil), (*GatewayMessage_RelayClose)(nil), + (*GatewayMessage_MainProcessExitAck)(nil), } - file_openshell_proto_msgTypes[133].OneofWrappers = []any{ + file_openshell_proto_msgTypes[135].OneofWrappers = []any{} + file_openshell_proto_msgTypes[137].OneofWrappers = []any{ (*RelayOpen_Ssh)(nil), (*RelayOpen_Tcp)(nil), } - file_openshell_proto_msgTypes[137].OneofWrappers = []any{ + file_openshell_proto_msgTypes[141].OneofWrappers = []any{ (*RelayFrame_Init)(nil), (*RelayFrame_Data)(nil), } - file_openshell_proto_msgTypes[167].OneofWrappers = []any{} - file_openshell_proto_msgTypes[168].OneofWrappers = []any{} + file_openshell_proto_msgTypes[171].OneofWrappers = []any{} + file_openshell_proto_msgTypes[172].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: 6, - NumMessages: 209, + NumEnums: 7, + NumMessages: 214, NumExtensions: 0, NumServices: 1, }, From 4f1ee6f3e13b089ac8518c4f20c009ad3f3ec116 Mon Sep 17 00:00:00 2001 From: Drew Newberry Date: Tue, 18 Aug 2026 09:19:19 -0700 Subject: [PATCH 2/8] feat(sandbox): simplify canonical main process contract Signed-off-by: Drew Newberry --- .agents/skills/openshell-cli/SKILL.md | 3 +- architecture/compute-runtimes.md | 12 +- architecture/gateway.md | 10 +- architecture/sandbox.md | 6 +- crates/openshell-cli/src/run.rs | 7 +- crates/openshell-cli/src/ssh.rs | 6 +- .../tests/ensure_providers_integration.rs | 7 + .../openshell-cli/tests/mtls_integration.rs | 7 + .../tests/provider_commands_integration.rs | 7 + .../sandbox_create_lifecycle_integration.rs | 16 +- .../sandbox_name_fallback_integration.rs | 7 + crates/openshell-core/src/driver_utils.rs | 1 - crates/openshell-core/src/sandbox_env.rs | 36 +- crates/openshell-driver-docker/src/lib.rs | 10 +- crates/openshell-driver-docker/src/tests.rs | 5 +- .../openshell-driver-kubernetes/src/driver.rs | 12 +- .../openshell-driver-podman/src/container.rs | 6 +- crates/openshell-driver-vm/src/driver.rs | 11 +- crates/openshell-sandbox/src/lib.rs | 82 +- crates/openshell-sandbox/src/main.rs | 25 +- .../openshell-sandbox/src/sidecar_control.rs | 101 +- crates/openshell-sdk/src/client.rs | 33 +- crates/openshell-sdk/src/lib.rs | 4 +- crates/openshell-sdk/src/types.rs | 48 +- crates/openshell-sdk/tests/client_mock.rs | 7 + crates/openshell-server/src/compute/mod.rs | 285 +- crates/openshell-server/src/grpc/mod.rs | 25 +- crates/openshell-server/src/grpc/sandbox.rs | 17 +- .../openshell-server/src/grpc/validation.rs | 95 +- .../src/supervisor_session.rs | 116 +- crates/openshell-server/src/test_support.rs | 1 - crates/openshell-server/tests/common/mod.rs | 7 + .../tests/supervisor_relay_integration.rs | 7 + .../openshell-supervisor-process/src/run.rs | 48 +- .../src/supervisor_session.rs | 50 +- docs/sandboxes/manage-sandboxes.mdx | 6 +- proto/compute_driver.proto | 18 +- proto/openshell.proto | 80 +- python/openshell/_proto/__init__.py | 2 - python/openshell/sandbox.py | 36 +- python/openshell/sandbox_test.py | 22 +- .../v1/internal/converter/coverage_test.go | 20 +- .../v1/internal/converter/sandbox.go | 32 +- .../v1/internal/converter/sandbox_test.go | 62 +- sdk/go/openshell/v1/types/sandbox.go | 40 +- sdk/go/proto/openshellv1/openshell.pb.go | 2625 ++++++++--------- sdk/go/proto/openshellv1/openshell_grpc.pb.go | 40 + 47 files changed, 1695 insertions(+), 2408 deletions(-) diff --git a/.agents/skills/openshell-cli/SKILL.md b/.agents/skills/openshell-cli/SKILL.md index 31dbfdb224..f08bc13b99 100644 --- a/.agents/skills/openshell-cli/SKILL.md +++ b/.agents/skills/openshell-cli/SKILL.md @@ -221,6 +221,7 @@ Key flags: - `--driver-config-json`: Pass experimental driver-specific sandbox configuration - `--label KEY=VALUE`: Add labels for later selection (repeatable) - `--env KEY=VALUE`: Set non-secret sandbox environment variables (repeatable); use `--provider` for credentials +- `--tty`: Allocate a retained PTY for the canonical main process - `--approval-mode manual|auto`: Control handling of agent-authored policy proposals; `manual` is the default - `--upload [:]`: Upload local files into the container working directory or an explicit destination - `--no-git-ignore`: Disable `.gitignore` filtering for uploads @@ -251,7 +252,7 @@ openshell sandbox connect my-sandbox --editor vscode ``` Attaches to the sandbox's existing canonical main process. Disconnecting leaves -that process running; reconnecting targets the same generation and replays +that process running; reconnecting targets the same process instance and replays recent output. Use `sandbox exec --tty -- /bin/bash -l` for a new shell. To configure VS Code Remote-SSH: diff --git a/architecture/compute-runtimes.md b/architecture/compute-runtimes.md index a2be242603..d98f038446 100644 --- a/architecture/compute-runtimes.md +++ b/architecture/compute-runtimes.md @@ -13,8 +13,9 @@ Each runtime receives a sandbox spec from the gateway and is responsible for: - Injecting sandbox identity and gateway callback configuration. - Supplying TLS or secret material for supervisor callbacks. - Providing the supervisor binary or image in the workload. -- Forwarding the exact canonical main-process argv, environment, working - directory, and terminal mode without shell reconstruction. +- Forwarding the exact canonical main-process argv and TTY mode without shell + reconstruction. The sandbox-level environment and policy workspace apply to + the main process. - Reporting lifecycle and platform events back to the gateway. - Cleaning up runtime-owned resources. @@ -25,10 +26,9 @@ references to gateway-internal types. The gateway owns the public `SandboxPhase::Ready` decision. This applies equally to extension drivers implementing `ComputeDriver` out of tree. -Drivers advertise canonical-process support in `GetCapabilities`. The gateway -rejects creation through older extension drivers that do not advertise the -capability, preventing a legacy idle entrypoint from silently replacing the -requested workload. +Canonical main-process support is part of the `ComputeDriver` contract. Every +in-tree and extension driver must forward the exact specification; it is not an +optional capability that drivers can omit or negotiate. Drivers own runtime-specific platform event interpretation. When an event should drive client provisioning UI, the driver attaches the shared diff --git a/architecture/gateway.md b/architecture/gateway.md index cf9d9a88e2..db94e80d8f 100644 --- a/architecture/gateway.md +++ b/architecture/gateway.md @@ -15,16 +15,18 @@ workloads. - Resolve provider credentials and inference bundles for sandbox supervisors. - Coordinate supervisor relay sessions for connect, exec, file sync, and service forwarding. -- Persist the canonical main-process generation and terminal result. Any main - process exit transitions the sandbox to `Error`, including exit code zero. +- Persist the canonical main-process instance ID and normalized exit code on + sandbox status. Any main process exit transitions the sandbox to `Error`, + including exit code zero. The gateway does not enforce agent network policy at request time. That happens inside each sandbox, where the supervisor and proxy can observe local process identity. The live supervisor session is the readiness authority for its main-process -generation. Short-lived exit-report sessions never replace that session or -mark the sandbox ready, and the gateway rejects stale generation results. +instance. The supervisor reports its normalized result through the +sandbox-authenticated `ReportMainProcessExit` RPC, and the gateway rejects +results from stale instance IDs. ## Protocol and Auth diff --git a/architecture/sandbox.md b/architecture/sandbox.md index ddb1f95c81..c966f5371e 100644 --- a/architecture/sandbox.md +++ b/architecture/sandbox.md @@ -407,6 +407,6 @@ engine with a gateway policy revision. - If the supervisor relay drops, the sandbox can keep running, but connect and exec operations fail until the supervisor registers again. - If the canonical main process exits, including with code 0, the supervisor - reports its result before shutdown. The gateway persists `MainProcessExited` - and makes the sandbox terminal `Error`; runtime restart policies must not - replace the process generation. + reports its normalized exit code before shutdown. The gateway persists the + code on sandbox status, records `MainProcessExited`, and makes the sandbox + terminal `Error`; runtime restart policies must not replace the process. diff --git a/crates/openshell-cli/src/run.rs b/crates/openshell-cli/src/run.rs index 94ec780951..1e302e9d0e 100644 --- a/crates/openshell-cli/src/run.rs +++ b/crates/openshell-cli/src/run.rs @@ -543,11 +543,8 @@ pub async fn sandbox_create( policy, providers: configured_providers, template, - main_process: Some(openshell_core::proto::MainProcessSpec { - command: main_command, - terminal: main_terminal, - ..Default::default() - }), + command: main_command, + tty: main_terminal, ..SandboxSpec::default() }), name: name.unwrap_or_default().to_string(), diff --git a/crates/openshell-cli/src/ssh.rs b/crates/openshell-cli/src/ssh.rs index 939107826a..4768dc27f2 100644 --- a/crates/openshell-cli/src/ssh.rs +++ b/crates/openshell-cli/src/ssh.rs @@ -140,11 +140,7 @@ async fn ssh_session_config( sandbox_id: session.sandbox_id.clone(), gateway_url, token: session.token, - main_terminal: sandbox - .spec - .as_ref() - .and_then(|spec| spec.main_process.as_ref()) - .is_none_or(|main| main.terminal), + main_terminal: sandbox.spec.as_ref().is_none_or(|spec| spec.tty), }) } diff --git a/crates/openshell-cli/tests/ensure_providers_integration.rs b/crates/openshell-cli/tests/ensure_providers_integration.rs index 3d628f2c10..831f9912bb 100644 --- a/crates/openshell-cli/tests/ensure_providers_integration.rs +++ b/crates/openshell-cli/tests/ensure_providers_integration.rs @@ -80,6 +80,13 @@ impl TestOpenShell { #[tonic::async_trait] impl OpenShell for TestOpenShell { + async fn report_main_process_exit( + &self, + _request: tonic::Request, + ) -> Result, Status> { + Err(Status::unimplemented("not used by this test server")) + } + async fn get_current_user( &self, _request: tonic::Request, diff --git a/crates/openshell-cli/tests/mtls_integration.rs b/crates/openshell-cli/tests/mtls_integration.rs index 60ffbd61f8..1a2a159b56 100644 --- a/crates/openshell-cli/tests/mtls_integration.rs +++ b/crates/openshell-cli/tests/mtls_integration.rs @@ -33,6 +33,13 @@ struct TestOpenShell; #[tonic::async_trait] impl OpenShell for TestOpenShell { + async fn report_main_process_exit( + &self, + _request: tonic::Request, + ) -> Result, Status> { + Err(Status::unimplemented("not used by this test server")) + } + async fn get_current_user( &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 a87ff0a6d8..f810c52d54 100644 --- a/crates/openshell-cli/tests/provider_commands_integration.rs +++ b/crates/openshell-cli/tests/provider_commands_integration.rs @@ -98,6 +98,13 @@ struct TestOpenShell { #[tonic::async_trait] impl OpenShell for TestOpenShell { + async fn report_main_process_exit( + &self, + _request: tonic::Request, + ) -> Result, Status> { + Err(Status::unimplemented("not used by this test server")) + } + async fn get_current_user( &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 721ebfd360..c7ac19ce93 100644 --- a/crates/openshell-cli/tests/sandbox_create_lifecycle_integration.rs +++ b/crates/openshell-cli/tests/sandbox_create_lifecycle_integration.rs @@ -60,6 +60,13 @@ struct TestOpenShell { #[tonic::async_trait] impl OpenShell for TestOpenShell { + async fn report_main_process_exit( + &self, + _request: tonic::Request, + ) -> Result, Status> { + Err(Status::unimplemented("not used by this test server")) + } + async fn get_current_user( &self, _request: tonic::Request, @@ -1320,13 +1327,12 @@ async fn sandbox_create_persists_exact_trailing_argv_as_main_process() { .expect("sandbox create should succeed"); let requests = create_requests(&server).await; - let main = requests[0] + let spec = requests[0] .spec .as_ref() - .and_then(|spec| spec.main_process.as_ref()) - .expect("main process should be persisted at create time"); - assert_eq!(main.command, command); - assert!(!main.terminal); + .expect("sandbox spec should be persisted at create time"); + assert_eq!(spec.command, command); + assert!(!spec.tty); } #[tokio::test] diff --git a/crates/openshell-cli/tests/sandbox_name_fallback_integration.rs b/crates/openshell-cli/tests/sandbox_name_fallback_integration.rs index 41b93bab82..acc2909972 100644 --- a/crates/openshell-cli/tests/sandbox_name_fallback_integration.rs +++ b/crates/openshell-cli/tests/sandbox_name_fallback_integration.rs @@ -48,6 +48,13 @@ struct TestOpenShell { #[tonic::async_trait] impl OpenShell for TestOpenShell { + async fn report_main_process_exit( + &self, + _request: tonic::Request, + ) -> Result, Status> { + Err(Status::unimplemented("not used by this test server")) + } + async fn get_current_user( &self, _request: tonic::Request, diff --git a/crates/openshell-core/src/driver_utils.rs b/crates/openshell-core/src/driver_utils.rs index 8b89002aa0..ae621fde08 100644 --- a/crates/openshell-core/src/driver_utils.rs +++ b/crates/openshell-core/src/driver_utils.rs @@ -385,7 +385,6 @@ pub fn build_capabilities_response( driver_name: driver_name.to_string(), driver_version: driver_version.into(), default_image: default_image.into(), - supports_main_process: true, } } diff --git a/crates/openshell-core/src/sandbox_env.rs b/crates/openshell-core/src/sandbox_env.rs index 751312a339..76faba74b3 100644 --- a/crates/openshell-core/src/sandbox_env.rs +++ b/crates/openshell-core/src/sandbox_env.rs @@ -8,8 +8,6 @@ //! supervisor process (which reads them on startup). Using constants here //! prevents typos from producing silently broken sandboxes. -use std::collections::HashMap; - use serde::{Deserialize, Serialize}; /// Name of the sandbox (used for policy sync and identification). @@ -38,9 +36,7 @@ pub const MAIN_PROCESS_SPEC: &str = "OPENSHELL_MAIN_PROCESS_SPEC"; pub struct MainProcessConfig { pub version: u32, pub command: Vec, - pub environment: HashMap, - pub working_directory: String, - pub terminal: bool, + pub tty: bool, } impl MainProcessConfig { @@ -51,20 +47,16 @@ impl MainProcessConfig { Self { version: Self::VERSION, command: vec!["/bin/bash".to_string(), "-l".to_string()], - environment: HashMap::new(), - working_directory: String::new(), - terminal: true, + tty: true, } } #[must_use] - pub fn from_driver_spec(spec: Option<&crate::proto::compute::v1::MainProcessSpec>) -> Self { + pub fn from_driver_spec(spec: Option<&crate::proto::compute::v1::DriverSandboxSpec>) -> Self { spec.map_or_else(Self::scratch, |spec| Self { version: Self::VERSION, command: spec.command.clone(), - environment: spec.environment.clone(), - working_directory: spec.working_directory.clone(), - terminal: spec.terminal, + tty: spec.tty, }) } @@ -86,7 +78,7 @@ impl MainProcessConfig { /// Encode the versioned driver-to-supervisor transport. pub fn encode_driver_spec( - spec: Option<&crate::proto::compute::v1::MainProcessSpec>, + spec: Option<&crate::proto::compute::v1::DriverSandboxSpec>, ) -> Result { serde_json::to_string(&Self::from_driver_spec(spec)) } @@ -203,26 +195,22 @@ mod tests { #[test] fn main_process_transport_preserves_argument_boundaries() { - let spec = crate::proto::compute::v1::MainProcessSpec { + let spec = crate::proto::compute::v1::DriverSandboxSpec { command: vec!["/bin/sh".into(), "-c".into(), "printf '%s' 'a b'".into()], - environment: HashMap::from([("MODE".into(), "a b".into())]), - working_directory: "/sandbox/work".into(), - terminal: false, + tty: false, + ..Default::default() }; let encoded = MainProcessConfig::encode_driver_spec(Some(&spec)).unwrap(); let decoded = MainProcessConfig::decode(&encoded).unwrap(); assert_eq!(decoded.command, spec.command); - assert_eq!(decoded.environment, spec.environment); - assert_eq!(decoded.working_directory, spec.working_directory); - assert!(!decoded.terminal); + assert!(!decoded.tty); } #[test] fn main_process_transport_rejects_unknown_version() { - let error = MainProcessConfig::decode( - r#"{"version":2,"command":["/bin/true"],"environment":{},"working_directory":"","terminal":false}"#, - ) - .unwrap_err(); + let error = + MainProcessConfig::decode(r#"{"version":2,"command":["/bin/true"],"tty":false}"#) + .unwrap_err(); assert!(error.contains("unsupported")); } } diff --git a/crates/openshell-driver-docker/src/lib.rs b/crates/openshell-driver-docker/src/lib.rs index 5e86641551..7ccf3c7693 100644 --- a/crates/openshell-driver-docker/src/lib.rs +++ b/crates/openshell-driver-docker/src/lib.rs @@ -2447,13 +2447,9 @@ fn build_environment_for_oci_user( openshell_core::sandbox_env::SSH_SOCKET_PATH.to_string(), config.ssh_socket_path.clone(), ); - let main_process = openshell_core::sandbox_env::MainProcessConfig::encode_driver_spec( - sandbox - .spec - .as_ref() - .and_then(|spec| spec.main_process.as_ref()), - ) - .expect("main process config serialization cannot fail"); + let main_process = + openshell_core::sandbox_env::MainProcessConfig::encode_driver_spec(sandbox.spec.as_ref()) + .expect("main process config serialization cannot fail"); environment.insert( openshell_core::sandbox_env::MAIN_PROCESS_SPEC.to_string(), main_process, diff --git a/crates/openshell-driver-docker/src/tests.rs b/crates/openshell-driver-docker/src/tests.rs index c1b15252bb..00b96baa76 100644 --- a/crates/openshell-driver-docker/src/tests.rs +++ b/crates/openshell-driver-docker/src/tests.rs @@ -45,7 +45,8 @@ fn test_sandbox() -> DriverSandbox { }), resource_requirements: None, sandbox_token: String::new(), - main_process: None, + command: Vec::new(), + tty: false, }), status: None, workspace: String::new(), @@ -629,7 +630,7 @@ fn build_environment_sets_docker_tls_paths() { .expect("main-process transport"); let main = openshell_core::sandbox_env::MainProcessConfig::decode(&encoded).unwrap(); assert_eq!(main.command, vec!["/bin/bash", "-l"]); - assert!(main.terminal); + assert!(main.tty); } #[test] diff --git a/crates/openshell-driver-kubernetes/src/driver.rs b/crates/openshell-driver-kubernetes/src/driver.rs index 932f15c29e..56dbe744a4 100644 --- a/crates/openshell-driver-kubernetes/src/driver.rs +++ b/crates/openshell-driver-kubernetes/src/driver.rs @@ -3336,7 +3336,7 @@ fn sandbox_to_k8s_spec( template, driver_gpu_requirements(spec.resource_requirements.as_ref()), &pod_env, - spec.main_process.as_ref(), + Some(spec), &driver_config, inject_workspace, params, @@ -3370,7 +3370,7 @@ fn sandbox_to_k8s_spec( &SandboxTemplate::default(), driver_gpu_requirements(spec.and_then(|s| s.resource_requirements.as_ref())), &pod_env, - spec.and_then(|spec| spec.main_process.as_ref()), + spec, &driver_config, inject_workspace, params, @@ -3430,7 +3430,7 @@ fn sandbox_template_to_k8s_with_validated_config( template: &SandboxTemplate, gpu_requirements: Option<&GpuResourceRequirements>, spec_environment: &std::collections::HashMap, - main_process: Option<&openshell_core::proto::compute::v1::MainProcessSpec>, + sandbox_spec: Option<&openshell_core::proto::compute::v1::DriverSandboxSpec>, driver_config: &KubernetesSandboxDriverConfig, inject_workspace: bool, params: &SandboxPodParams<'_>, @@ -3567,7 +3567,7 @@ fn sandbox_template_to_k8s_with_validated_config( None, &template.environment, spec_environment, - main_process, + sandbox_spec, params.sandbox_id, params.sandbox_name, params.grpc_endpoint, @@ -3937,7 +3937,7 @@ fn build_env_list( existing_env: Option<&Vec>, template_environment: &std::collections::HashMap, spec_environment: &std::collections::HashMap, - main_process: Option<&openshell_core::proto::compute::v1::MainProcessSpec>, + sandbox_spec: Option<&openshell_core::proto::compute::v1::DriverSandboxSpec>, sandbox_id: &str, sandbox_name: &str, grpc_endpoint: &str, @@ -3960,7 +3960,7 @@ fn build_env_list( ); } let main_process = - openshell_core::sandbox_env::MainProcessConfig::encode_driver_spec(main_process) + openshell_core::sandbox_env::MainProcessConfig::encode_driver_spec(sandbox_spec) .expect("main process config serialization cannot fail"); upsert_env( &mut env, diff --git a/crates/openshell-driver-podman/src/container.rs b/crates/openshell-driver-podman/src/container.rs index 6ee822f2f6..ea22a757b1 100644 --- a/crates/openshell-driver-podman/src/container.rs +++ b/crates/openshell-driver-podman/src/container.rs @@ -516,10 +516,8 @@ fn build_env( config.sandbox_ssh_socket_path.clone(), ); env.insert("OPENSHELL_CONTAINER_IMAGE".into(), image.to_string()); - let main_process = openshell_core::sandbox_env::MainProcessConfig::encode_driver_spec( - spec.and_then(|spec| spec.main_process.as_ref()), - ) - .expect("main process config serialization cannot fail"); + let main_process = openshell_core::sandbox_env::MainProcessConfig::encode_driver_spec(spec) + .expect("main process config serialization cannot fail"); env.insert( openshell_core::sandbox_env::MAIN_PROCESS_SPEC.into(), main_process, diff --git a/crates/openshell-driver-vm/src/driver.rs b/crates/openshell-driver-vm/src/driver.rs index 31d1a465b2..950d18cc49 100644 --- a/crates/openshell-driver-vm/src/driver.rs +++ b/crates/openshell-driver-vm/src/driver.rs @@ -523,7 +523,6 @@ impl VmDriver { driver_name: DRIVER_NAME.to_string(), driver_version: openshell_core::VERSION.to_string(), default_image: self.config.default_image.clone(), - supports_main_process: true, } } @@ -4489,13 +4488,9 @@ fn build_guest_environment( openshell_core::sandbox_env::SSH_SOCKET_PATH.to_string(), GUEST_SSH_SOCKET_PATH.to_string(), ); - let main_process = openshell_core::sandbox_env::MainProcessConfig::encode_driver_spec( - sandbox - .spec - .as_ref() - .and_then(|spec| spec.main_process.as_ref()), - ) - .expect("main process config serialization cannot fail"); + let main_process = + openshell_core::sandbox_env::MainProcessConfig::encode_driver_spec(sandbox.spec.as_ref()) + .expect("main process config serialization cannot fail"); environment.insert( openshell_core::sandbox_env::MAIN_PROCESS_SPEC.to_string(), main_process, diff --git a/crates/openshell-sandbox/src/lib.rs b/crates/openshell-sandbox/src/lib.rs index 537097ce67..f26e4e4442 100644 --- a/crates/openshell-sandbox/src/lib.rs +++ b/crates/openshell-sandbox/src/lib.rs @@ -93,7 +93,6 @@ pub async fn run_sandbox( main_workdir: Option, timeout_secs: u64, interactive: bool, - main_environment: std::collections::HashMap, sandbox_id: Option, sandbox: Option, openshell_endpoint: Option, @@ -716,8 +715,7 @@ pub async fn run_sandbox( } let process_policy = process_policy_for_topology(&policy, sidecar_network_enforcement)?; - let mut main_env = provider_env.clone(); - main_env.extend(main_environment); + let main_env = provider_env.clone(); let sidecar_bootstrap_ca_file_paths = sidecar_bootstrap.as_ref().and_then(|bootstrap| { bootstrap .proxy_ca_cert_path @@ -739,28 +737,28 @@ pub async fn run_sandbox( } }); - let entrypoint_started_tx = if process_uses_sidecar_control - && let Some(writer) = process_control_writer.clone() - { - let (tx, rx) = tokio::sync::oneshot::channel(); - tokio::spawn(async move { - match rx.await { - Ok((pid, generation)) => { - if let Err(err) = - sidecar_control::send_entrypoint_started(&writer, pid, generation).await - { - warn!(error = %err, "Failed to send sidecar entrypoint event"); + let entrypoint_started_tx = + if process_uses_sidecar_control && let Some(writer) = process_control_writer.clone() { + let (tx, rx) = tokio::sync::oneshot::channel(); + tokio::spawn(async move { + match rx.await { + Ok((pid, instance_id)) => { + if let Err(err) = + sidecar_control::send_entrypoint_started(&writer, pid, instance_id) + .await + { + warn!(error = %err, "Failed to send sidecar entrypoint event"); + } + } + Err(_closed) => { + debug!("Entrypoint exited before sidecar entrypoint event was sent"); } } - Err(_closed) => { - debug!("Entrypoint exited before sidecar entrypoint event was sent"); - } - } - }); - Some(tx) - } else { - None - }; + }); + Some(tx) + } else { + None + }; let sidecar_exit_tx = if process_uses_sidecar_control && let Some(writer) = process_control_writer.clone() { let exit_ack = Arc::clone(&process_exit_ack); @@ -768,17 +766,21 @@ pub async fn run_sandbox( openshell_supervisor_process::run::SidecarExitReport, >(1); tokio::spawn(async move { - while let Some((exit, ack)) = rx.recv().await { - let generation = exit.generation.clone(); + while let Some((instance_id, exit_code, ack)) = rx.recv().await { let (durable_tx, durable_rx) = tokio::sync::oneshot::channel(); - *exit_ack.lock().await = Some((generation, durable_tx)); - let result = - match sidecar_control::send_main_process_exited(&writer, exit).await { - Ok(()) => durable_rx.await.map_err(|_| { - "sidecar durable exit acknowledgement closed".to_string() - }), - Err(error) => Err(error.to_string()), - }; + *exit_ack.lock().await = Some((instance_id.clone(), durable_tx)); + let result = match sidecar_control::send_main_process_exited( + &writer, + instance_id, + exit_code, + ) + .await + { + Ok(()) => durable_rx.await.map_err(|_| { + "sidecar durable exit acknowledgement closed".to_string() + }), + Err(error) => Err(error.to_string()), + }; let _ = ack.send(result); } }); @@ -1026,11 +1028,11 @@ fn spawn_sidecar_control_update_watcher( skills::install_static_skills, ); } - sidecar_control::ControlUpdate::MainProcessExitAck { generation } => { + sidecar_control::ControlUpdate::MainProcessExitAck { instance_id } => { let mut waiter = exit_ack.lock().await; if waiter .as_ref() - .is_some_and(|(expected, _)| expected == &generation) + .is_some_and(|(expected, _)| expected == &instance_id) && let Some((_, ack)) = waiter.take() { let _ = ack.send(()); @@ -1071,7 +1073,7 @@ fn spawn_sidecar_entrypoint_handler( let mut trusted_supervisor_pid = None; let terminating = Arc::new(AtomicBool::new(false)); while let Some(started) = entrypoint_rx.recv().await { - if let Some(exit) = started.exit { + if let Some(exit_code) = started.exit_code { terminating.store(true, Ordering::Release); if let (Some(endpoint), Some(id)) = (openshell_endpoint.as_ref(), sandbox_id.as_ref()) @@ -1081,8 +1083,8 @@ fn spawn_sidecar_entrypoint_handler( match openshell_supervisor_process::supervisor_session::report_main_process_exit( endpoint, id, - &exit.generation, - exit.clone(), + &started.instance_id, + exit_code, ) .await { @@ -1095,7 +1097,7 @@ fn spawn_sidecar_entrypoint_handler( } } if let Some(publisher) = control_publisher.as_ref() { - publisher.publish_main_process_exit_ack(exit.generation.clone()); + publisher.publish_main_process_exit_ack(started.instance_id.clone()); } } break; @@ -1148,7 +1150,7 @@ fn spawn_sidecar_entrypoint_handler( None, Some(supervisor_pid), Arc::clone(&terminating), - started.generation.clone(), + started.instance_id.clone(), ); session_started = true; info!("sidecar supervisor session task spawned"); diff --git a/crates/openshell-sandbox/src/main.rs b/crates/openshell-sandbox/src/main.rs index cb4bf802be..61bd941159 100644 --- a/crates/openshell-sandbox/src/main.rs +++ b/crates/openshell-sandbox/src/main.rs @@ -647,37 +647,21 @@ fn main() -> Result<()> { // drivers otherwise provide a versioned JSON transport so argument // boundaries are never reconstructed with shell parsing. let policy_workdir = args.workdir.clone(); - let (command, main_workdir, interactive, main_environment) = if !args.command.is_empty() { - ( - args.command, - policy_workdir.clone(), - args.interactive, - std::collections::HashMap::default(), - ) + let (command, main_workdir, interactive) = if !args.command.is_empty() { + (args.command, policy_workdir.clone(), args.interactive) } else if let Ok(json) = std::env::var(openshell_core::sandbox_env::MAIN_PROCESS_SPEC) { let config = openshell_core::sandbox_env::MainProcessConfig::decode(&json) .map_err(|error| miette::miette!("{error}"))?; - let workdir = if config.working_directory.is_empty() { - policy_workdir.clone() - } else { - Some(config.working_directory) - }; - (config.command, workdir, config.terminal, config.environment) + (config.command, policy_workdir.clone(), config.tty) } else if let Ok(c) = std::env::var(openshell_core::sandbox_env::SANDBOX_COMMAND) { ( c.split_whitespace().map(String::from).collect(), policy_workdir.clone(), args.interactive, - std::collections::HashMap::default(), ) } else { let config = openshell_core::sandbox_env::MainProcessConfig::scratch(); - ( - config.command, - policy_workdir.clone(), - config.terminal, - config.environment, - ) + (config.command, policy_workdir.clone(), config.tty) }; info!(command = ?command, "Starting sandbox"); @@ -699,7 +683,6 @@ fn main() -> Result<()> { main_workdir, args.timeout, interactive, - main_environment, args.sandbox_id, args.sandbox, args.openshell_endpoint, diff --git a/crates/openshell-sandbox/src/sidecar_control.rs b/crates/openshell-sandbox/src/sidecar_control.rs index e01ab5295b..ce0f20657e 100644 --- a/crates/openshell-sandbox/src/sidecar_control.rs +++ b/crates/openshell-sandbox/src/sidecar_control.rs @@ -35,8 +35,8 @@ pub struct BootstrapData { pub struct EntrypointStarted { pub pid: u32, pub start_session: bool, - pub generation: String, - pub exit: Option, + pub instance_id: String, + pub exit_code: Option, } #[derive(Debug, Clone, Copy)] @@ -61,7 +61,7 @@ pub enum ControlUpdate { config_revision: u64, }, MainProcessExitAck { - generation: String, + instance_id: String, }, } @@ -121,10 +121,10 @@ impl Publisher { }); } - pub fn publish_main_process_exit_ack(&self, generation: String) { + pub fn publish_main_process_exit_ack(&self, instance_id: String) { let _ = self .updates - .send(WireServerMessage::MainProcessExitAck { generation }); + .send(WireServerMessage::MainProcessExitAck { instance_id }); } } @@ -165,20 +165,9 @@ pub struct ProcessConnection { #[derive(Debug, Serialize, Deserialize)] #[serde(tag = "type", rename_all = "snake_case")] enum WireClientMessage { - BootstrapRequest { - supervisor_pid: u32, - }, - EntrypointStarted { - pid: u32, - generation: String, - }, - MainProcessExited { - generation: String, - exit_code: Option, - signal: Option, - started_at_ms: i64, - finished_at_ms: i64, - }, + BootstrapRequest { supervisor_pid: u32 }, + EntrypointStarted { pid: u32, instance_id: String }, + MainProcessExited { instance_id: String, exit_code: i32 }, } #[derive(Debug, Clone, Serialize, Deserialize)] @@ -206,7 +195,7 @@ enum WireServerMessage { config_revision: u64, }, MainProcessExitAck { - generation: String, + instance_id: String, }, } @@ -297,8 +286,8 @@ impl TryFrom for ControlUpdate { enabled, config_revision, }), - WireServerMessage::MainProcessExitAck { generation } => { - Ok(Self::MainProcessExitAck { generation }) + WireServerMessage::MainProcessExitAck { instance_id } => { + Ok(Self::MainProcessExitAck { instance_id }) } WireServerMessage::BootstrapResponse { .. } => Err(miette::miette!( "unexpected sidecar bootstrap response after initial handshake" @@ -460,8 +449,8 @@ async fn handle_connection( .send(EntrypointStarted { pid: supervisor_pid, start_session: false, - generation: String::new(), - exit: None, + instance_id: String::new(), + exit_code: None, }) .await .map_err(|_| miette::miette!("sidecar entrypoint receiver closed"))?; @@ -494,7 +483,7 @@ async fn handle_connection( WireClientMessage::BootstrapRequest { .. } => { debug!("Ignoring duplicate sidecar bootstrap request"); } - WireClientMessage::EntrypointStarted { pid, generation } => { + WireClientMessage::EntrypointStarted { pid, instance_id } => { if pid == 0 { warn!("Ignoring sidecar entrypoint event with pid=0"); continue; @@ -503,31 +492,22 @@ async fn handle_connection( .send(EntrypointStarted { pid, start_session: true, - generation, - exit: None, + instance_id, + exit_code: None, }) .await .map_err(|_| miette::miette!("sidecar entrypoint receiver closed"))?; } WireClientMessage::MainProcessExited { - generation, + instance_id, exit_code, - signal, - started_at_ms, - finished_at_ms, } => { entrypoint_tx .send(EntrypointStarted { pid: 0, start_session: false, - generation: generation.clone(), - exit: Some(openshell_core::proto::MainProcessExit { - generation, - exit_code, - signal, - started_at_ms, - finished_at_ms, - }), + instance_id, + exit_code: Some(exit_code), }) .await .map_err(|_| miette::miette!("sidecar entrypoint receiver closed"))?; @@ -625,23 +605,21 @@ async fn connect_with_retry(path: &Path, timeout: Duration) -> Result>, pid: u32, - generation: String, + instance_id: String, ) -> Result<()> { - let message = WireClientMessage::EntrypointStarted { pid, generation }; + let message = WireClientMessage::EntrypointStarted { pid, instance_id }; let mut writer = writer.lock().await; write_json_line(&mut *writer, &message).await } pub async fn send_main_process_exited( writer: &Arc>, - exit: openshell_core::proto::MainProcessExit, + instance_id: String, + exit_code: i32, ) -> Result<()> { let message = WireClientMessage::MainProcessExited { - generation: exit.generation, - exit_code: exit.exit_code, - signal: exit.signal, - started_at_ms: exit.started_at_ms, - finished_at_ms: exit.finished_at_ms, + instance_id, + exit_code, }; let mut writer = writer.lock().await; write_json_line(&mut *writer, &message).await @@ -791,7 +769,7 @@ mod tests { assert_eq!(anchor.pid, std::process::id()); assert!(!anchor.start_session); - send_entrypoint_started(&connection.writer, 4242, "generation-1".to_string()) + send_entrypoint_started(&connection.writer, 4242, "instance-1".to_string()) .await .unwrap(); @@ -801,26 +779,17 @@ mod tests { .unwrap(); assert_eq!(started.pid, 4242); assert!(started.start_session); - assert_eq!(started.generation, "generation-1"); - assert!(started.exit.is_none()); - - send_main_process_exited( - &connection.writer, - openshell_core::proto::MainProcessExit { - generation: "generation-1".to_string(), - exit_code: Some(0), - signal: None, - started_at_ms: 10, - finished_at_ms: 20, - }, - ) - .await - .unwrap(); + assert_eq!(started.instance_id, "instance-1"); + assert!(started.exit_code.is_none()); + + send_main_process_exited(&connection.writer, "instance-1".to_string(), 0) + .await + .unwrap(); let terminal = tokio::time::timeout(Duration::from_secs(1), entrypoint_rx.recv()) .await .unwrap() .unwrap(); - assert_eq!(terminal.exit.unwrap().exit_code, Some(0)); + assert_eq!(terminal.exit_code, Some(0)); assert!( tokio::time::timeout(Duration::from_millis(20), connection.updates.recv()) @@ -828,14 +797,14 @@ mod tests { .is_err(), "process side must not observe a durable ACK before gateway persistence" ); - publisher.publish_main_process_exit_ack("generation-1".to_string()); + publisher.publish_main_process_exit_ack("instance-1".to_string()); let ack = tokio::time::timeout(Duration::from_secs(1), connection.updates.recv()) .await .unwrap() .unwrap(); assert!(matches!( ack, - ControlUpdate::MainProcessExitAck { generation } if generation == "generation-1" + ControlUpdate::MainProcessExitAck { instance_id } if instance_id == "instance-1" )); } diff --git a/crates/openshell-sdk/src/client.rs b/crates/openshell-sdk/src/client.rs index 4c1920aab5..f95b7ee111 100644 --- a/crates/openshell-sdk/src/client.rs +++ b/crates/openshell-sdk/src/client.rs @@ -799,7 +799,8 @@ fn create_sandbox_request(spec: SandboxSpec) -> proto::CreateSandboxRequest { environment, providers, gpu, - main_process, + command, + tty, } = spec; let template = image.map(|image| proto::SandboxTemplate { image, @@ -814,12 +815,8 @@ fn create_sandbox_request(spec: SandboxSpec) -> proto::CreateSandboxRequest { template, providers, resource_requirements, - main_process: main_process.map(|main| proto::MainProcessSpec { - command: main.command, - environment: main.environment, - working_directory: main.working_directory.unwrap_or_default(), - terminal: main.terminal, - }), + command, + tty, ..proto::SandboxSpec::default() }), name: name.unwrap_or_default(), @@ -1003,25 +1000,13 @@ mod tests { #[test] fn create_request_preserves_canonical_main_process() { let request = create_sandbox_request(SandboxSpec { - main_process: Some(crate::types::MainProcessSpec { - command: vec!["/opt/agent binary".into(), "--serve exactly".into()], - environment: HashMap::from([("MODE".into(), "worker".into())]), - working_directory: Some("/sandbox/app".into()), - terminal: false, - }), + command: vec!["/opt/agent binary".into(), "--serve exactly".into()], + tty: false, ..SandboxSpec::default() }); - let main = request - .spec - .and_then(|spec| spec.main_process) - .expect("main process should be present"); - assert_eq!(main.command, ["/opt/agent binary", "--serve exactly"]); - assert_eq!( - main.environment.get("MODE").map(String::as_str), - Some("worker") - ); - assert_eq!(main.working_directory, "/sandbox/app"); - assert!(!main.terminal); + let spec = request.spec.expect("sandbox spec should be present"); + assert_eq!(spec.command, ["/opt/agent binary", "--serve exactly"]); + assert!(!spec.tty); } } diff --git a/crates/openshell-sdk/src/lib.rs b/crates/openshell-sdk/src/lib.rs index 005b8b7efe..dbf2524a2a 100644 --- a/crates/openshell-sdk/src/lib.rs +++ b/crates/openshell-sdk/src/lib.rs @@ -46,6 +46,6 @@ pub use config::{AuthConfig, ClientConfig}; pub use error::SdkError; pub use refresh::{Refresh, RefreshError, RefreshedToken, TokenSource}; pub use types::{ - ExecOptions, ExecResult, Health, ListOptions, MainProcessSpec, MainProcessStatus, SandboxPhase, - SandboxRef, SandboxSpec, ServiceStatus, WorkspaceRef, + ExecOptions, ExecResult, Health, ListOptions, SandboxPhase, SandboxRef, SandboxSpec, + ServiceStatus, WorkspaceRef, }; diff --git a/crates/openshell-sdk/src/types.rs b/crates/openshell-sdk/src/types.rs index acd1f74f7a..cdf66c3995 100644 --- a/crates/openshell-sdk/src/types.rs +++ b/crates/openshell-sdk/src/types.rs @@ -109,28 +109,10 @@ pub struct SandboxSpec { /// Request a GPU. Driver-specific device selection is configured via /// driver config on the raw proto surface (see [`crate::raw`]). pub gpu: bool, - /// Exact canonical process. `None` selects the gateway's scratch login shell. - pub main_process: Option, -} - -/// Shell-free canonical main-process configuration. -#[derive(Clone, Debug)] -pub struct MainProcessSpec { + /// Exact canonical command. Empty selects the gateway's scratch login shell. pub command: Vec, - pub environment: HashMap, - pub working_directory: Option, - pub terminal: bool, -} - -/// Last observed canonical-process generation and result. -#[derive(Clone, Debug)] -pub struct MainProcessStatus { - pub state: i32, - pub generation: String, - pub exit_code: Option, - pub signal: Option, - pub started_at_ms: i64, - pub finished_at_ms: i64, + /// Allocate a retained pseudo-terminal for the canonical command. + pub tty: bool, } /// Reference to a sandbox owned by the gateway. @@ -143,23 +125,20 @@ pub struct SandboxRef { pub phase: SandboxPhase, pub labels: HashMap, pub resource_version: u64, - pub main_process: Option, + pub main_process_instance_id: Option, + pub exit_code: Option, } impl SandboxRef { pub(crate) fn from_proto(sandbox: proto::Sandbox) -> Self { let phase = sandbox.phase().into(); - let main_process = sandbox - .status - .as_ref() - .and_then(|status| status.main_process.as_ref()) - .map(|main| MainProcessStatus { - state: main.state, - generation: main.generation.clone(), - exit_code: main.exit_code, - signal: main.signal, - started_at_ms: main.started_at_ms, - finished_at_ms: main.finished_at_ms, + let (main_process_instance_id, exit_code) = + sandbox.status.as_ref().map_or((None, None), |status| { + ( + (!status.main_process_instance_id.is_empty()) + .then(|| status.main_process_instance_id.clone()), + status.exit_code, + ) }); let meta = sandbox.metadata.unwrap_or_default(); Self { @@ -169,7 +148,8 @@ impl SandboxRef { phase, labels: meta.labels, resource_version: meta.resource_version, - main_process, + main_process_instance_id, + exit_code, } } } diff --git a/crates/openshell-sdk/tests/client_mock.rs b/crates/openshell-sdk/tests/client_mock.rs index 09e91330ce..c5467b809d 100644 --- a/crates/openshell-sdk/tests/client_mock.rs +++ b/crates/openshell-sdk/tests/client_mock.rs @@ -100,6 +100,13 @@ fn workspace_proto(name: &str, phase: proto::datamodel::v1::WorkspacePhase) -> p #[tonic::async_trait] impl OpenShell for TestOpenShell { + async fn report_main_process_exit( + &self, + _request: tonic::Request, + ) -> Result, Status> { + Err(Status::unimplemented("not used by this test server")) + } + async fn get_current_user( &self, _request: tonic::Request, diff --git a/crates/openshell-server/src/compute/mod.rs b/crates/openshell-server/src/compute/mod.rs index 5d2532d277..aa971277a9 100644 --- a/crates/openshell-server/src/compute/mod.rs +++ b/crates/openshell-server/src/compute/mod.rs @@ -45,8 +45,8 @@ use openshell_core::proto::compute::v1::{ gateway_listener_requirement::Selector, watch_sandboxes_event, }; use openshell_core::proto::{ - MainProcessExit, MainProcessState, MainProcessStatus, PlatformEvent, Sandbox, SandboxCondition, - SandboxPhase, SandboxSpec, SandboxStatus, SandboxTemplate, ServiceEndpoint, SshSession, + PlatformEvent, Sandbox, SandboxCondition, SandboxPhase, SandboxSpec, SandboxStatus, + SandboxTemplate, ServiceEndpoint, SshSession, }; use openshell_core::{ObjectLabels, ObjectWorkspace}; #[cfg(not(target_os = "windows"))] @@ -274,8 +274,6 @@ pub struct ComputeDriverInfoSnapshot { pub driver_name: String, /// Driver-reported implementation version from the startup capability snapshot. pub driver_version: String, - /// Whether the driver forwards canonical main-process specifications. - pub supports_main_process: bool, } #[tonic::async_trait] @@ -596,7 +594,6 @@ pub struct ComputeRuntime { startup_starter: Option>, driver_process: Option>, default_image: String, - supports_main_process: bool, store: Arc, sandbox_index: SandboxIndex, sandbox_watch_bus: SandboxWatchBus, @@ -656,10 +653,8 @@ impl ComputeRuntime { name: driver_name.clone(), driver_name: capabilities.driver_name, driver_version: capabilities.driver_version, - supports_main_process: capabilities.supports_main_process, }; let default_image = capabilities.default_image; - let supports_main_process = capabilities.supports_main_process; let gateway_listener_requirements = match driver .get_gateway_listener_requirements(Request::new( GetGatewayListenerRequirementsRequest {}, @@ -720,7 +715,6 @@ impl ComputeRuntime { startup_starter, driver_process, default_image, - supports_main_process, store, sandbox_index, sandbox_watch_bus, @@ -929,18 +923,6 @@ impl ComputeRuntime { } pub async fn validate_sandbox_create(&self, sandbox: &Sandbox) -> Result<(), Status> { - if sandbox - .spec - .as_ref() - .and_then(|spec| spec.main_process.as_ref()) - .is_some() - && !self.supports_main_process - { - return Err(Status::failed_precondition(format!( - "compute driver '{}' does not support canonical main processes; upgrade the driver before creating sandboxes", - self.driver_info.name - ))); - } let driver_sandbox = driver_sandbox_from_public(sandbox, &self.driver_info.name) .map_err(|status| *status)?; self.driver @@ -1459,6 +1441,11 @@ impl ComputeRuntime { move |sandbox| { sandbox.set_phase(phase as i32); let name = sandbox.object_name().to_string(); + if matches!(phase, SandboxPhase::Stopping | SandboxPhase::Starting) { + let status = sandbox.status.get_or_insert_with(Default::default); + status.main_process_instance_id.clear(); + status.exit_code = None; + } upsert_ready_condition( &mut sandbox.status, &name, @@ -2720,9 +2707,9 @@ impl ComputeRuntime { pub async fn supervisor_session_connected( &self, sandbox_id: &str, - generation: &str, + instance_id: &str, ) -> Result<(), String> { - self.set_supervisor_session_state(sandbox_id, true, Some(generation)) + self.set_supervisor_session_state(sandbox_id, true, Some(instance_id)) .await } @@ -2735,7 +2722,7 @@ impl ComputeRuntime { &self, sandbox_id: &str, connected: bool, - generation: Option<&str>, + instance_id: Option<&str>, ) -> Result<(), String> { let _guard = self.sync_lock.lock().await; @@ -2771,12 +2758,8 @@ impl ComputeRuntime { if connected { ensure_supervisor_ready_status(&mut sandbox.status, &sandbox_name); let status = sandbox.status.get_or_insert_with(Default::default); - status.main_process = Some(MainProcessStatus { - state: MainProcessState::Running as i32, - generation: generation.unwrap_or_default().to_string(), - started_at_ms: crate::persistence::current_time_ms(), - ..Default::default() - }); + status.main_process_instance_id = instance_id.unwrap_or_default().to_string(); + status.exit_code = None; sandbox.set_phase(SandboxPhase::Ready as i32); } else { ensure_supervisor_not_ready_status(&mut sandbox.status, &sandbox_name); @@ -2815,7 +2798,8 @@ impl ComputeRuntime { pub async fn main_process_exited( &self, sandbox_id: &str, - exit: &MainProcessExit, + instance_id: &str, + exit_code: i32, ) -> Result<(), String> { let _guard = self.sync_lock.lock().await; let Some(existing) = self @@ -2833,43 +2817,30 @@ impl ComputeRuntime { ) { return Ok(()); } - let current = existing - .status - .as_ref() - .and_then(|status| status.main_process.as_ref()); - if let Some(current) = current { - if current.generation != exit.generation { + if let Some(status) = existing.status.as_ref() { + if !status.main_process_instance_id.is_empty() + && status.main_process_instance_id != instance_id + { return Err(format!( - "stale main-process exit generation '{}' (active generation is '{}')", - exit.generation, current.generation + "stale main-process exit instance '{instance_id}' (active instance is '{}')", + status.main_process_instance_id )); } - if MainProcessState::try_from(current.state).unwrap_or(MainProcessState::Unspecified) - == MainProcessState::Exited - { - let current_has_precise_result = - current.exit_code.is_some() || current.signal.is_some(); - let incoming_has_precise_result = exit.exit_code.is_some() || exit.signal.is_some(); - if !current_has_precise_result && incoming_has_precise_result { - // A terminal driver snapshot can beat the supervisor report - // and record only that the process exited. Let the durable - // supervisor report enrich that fallback with the exact - // result instead of treating it as a duplicate. - } else if current.exit_code == exit.exit_code && current.signal == exit.signal { - return Ok(()); + if let Some(current_exit_code) = status.exit_code { + return if current_exit_code == exit_code { + Ok(()) } else { - return Err(format!( - "conflicting main-process exit result for generation '{}'", - exit.generation - )); - } + Err(format!( + "conflicting main-process exit result for instance '{instance_id}'" + )) + }; } } let expected_resource_version = sandbox_resource_version(&existing); let sandbox = self .store .update_message_cas::(sandbox_id, expected_resource_version, |sandbox| { - apply_main_process_exit(sandbox, exit); + apply_main_process_exit(sandbox, instance_id, exit_code); }) .await .map_err(|error| error.to_string())?; @@ -3232,20 +3203,14 @@ impl ComputeRuntime { } } -fn apply_main_process_exit(sandbox: &mut Sandbox, exit: &MainProcessExit) { +fn apply_main_process_exit(sandbox: &mut Sandbox, instance_id: &str, exit_code: i32) { let sandbox_name = sandbox.object_name().to_string(); let status = sandbox.status.get_or_insert_with(|| SandboxStatus { sandbox_name: sandbox_name.clone(), ..Default::default() }); - status.main_process = Some(MainProcessStatus { - state: MainProcessState::Exited as i32, - generation: exit.generation.clone(), - exit_code: exit.exit_code, - signal: exit.signal, - started_at_ms: exit.started_at_ms, - finished_at_ms: exit.finished_at_ms, - }); + status.main_process_instance_id = instance_id.to_string(); + status.exit_code = Some(exit_code); upsert_ready_condition( &mut sandbox.status, &sandbox_name, @@ -3338,19 +3303,8 @@ fn driver_sandbox_spec_from_public( } }), sandbox_token: String::new(), - main_process: Some(spec.main_process.as_ref().map_or_else( - || openshell_core::proto::compute::v1::MainProcessSpec { - command: vec!["/bin/bash".to_string(), "-l".to_string()], - terminal: true, - ..Default::default() - }, - |main_process| openshell_core::proto::compute::v1::MainProcessSpec { - command: main_process.command.clone(), - environment: main_process.environment.clone(), - working_directory: main_process.working_directory.clone(), - terminal: main_process.terminal, - }, - )), + command: spec.command.clone(), + tty: spec.tty, }) } @@ -3622,7 +3576,8 @@ fn public_status_from_driver( .collect(), phase: phase as i32, current_policy_version, - main_process: None, + main_process_instance_id: String::new(), + exit_code: None, } } @@ -3695,24 +3650,6 @@ fn apply_driver_snapshot(sandbox: &mut Sandbox, incoming: &DriverSandbox, sessio { status.sandbox_name.clone_from(sandbox_name); } - if let Some(status) = status.as_mut() { - let mut main_process = sandbox - .status - .as_ref() - .and_then(|current| current.main_process.clone()); - if phase == SandboxPhase::Error - && let Some(terminal) = main_process.as_mut() - && MainProcessState::try_from(terminal.state).unwrap_or(MainProcessState::Unspecified) - == MainProcessState::Running - { - terminal.state = MainProcessState::Exited as i32; - terminal.exit_code = None; - terminal.signal = None; - terminal.finished_at_ms = crate::persistence::current_time_ms(); - } - status.main_process = main_process; - } - if old_phase != phase { info!( sandbox_id = %incoming.id, @@ -4022,7 +3959,6 @@ impl ComputeDriver for NoopTestDriver { driver_name: "noop-test-driver".to_string(), driver_version: "test".to_string(), default_image: "openshell/sandbox:test".to_string(), - supports_main_process: true, }, )) } @@ -4163,13 +4099,11 @@ pub async fn new_test_runtime_with_driver( name: driver_name.to_string(), driver_name: driver_name.to_string(), driver_version: "test".to_string(), - supports_main_process: true, }, shutdown_cleanup: None, startup_starter: None, driver_process: None, default_image: "openshell/sandbox:test".to_string(), - supports_main_process: true, store, sandbox_index: SandboxIndex::new(), sandbox_watch_bus: SandboxWatchBus::new(), @@ -4329,7 +4263,6 @@ mod tests { driver_name: "test-driver".to_string(), driver_version: "test".to_string(), default_image: "openshell/sandbox:test".to_string(), - supports_main_process: true, })) } @@ -4628,7 +4561,6 @@ mod tests { driver_name: "controlled-test-driver".to_string(), driver_version: "test".to_string(), default_image: "openshell/sandbox:test".to_string(), - supports_main_process: true, })) } @@ -4819,13 +4751,11 @@ mod tests { name: "test-driver".to_string(), driver_name: "test-driver".to_string(), driver_version: "test".to_string(), - supports_main_process: true, }, shutdown_cleanup: None, startup_starter, driver_process: None, default_image: "openshell/sandbox:test".to_string(), - supports_main_process: true, store, sandbox_index: SandboxIndex::new(), sandbox_watch_bus: SandboxWatchBus::new(), @@ -4849,25 +4779,6 @@ mod tests { ); } - #[tokio::test] - async fn canonical_process_requires_driver_capability() { - let mut runtime = test_runtime(Arc::new(TestDriver::default())).await; - runtime.supports_main_process = false; - let mut sandbox = sandbox_record("sb-1", "sandbox-a", SandboxPhase::Provisioning); - sandbox.spec = Some(SandboxSpec { - main_process: Some(openshell_core::proto::MainProcessSpec::default()), - ..Default::default() - }); - - let error = runtime.validate_sandbox_create(&sandbox).await.unwrap_err(); - assert_eq!(error.code(), Code::FailedPrecondition); - assert!( - error - .message() - .contains("does not support canonical main processes") - ); - } - fn sandbox_record(id: &str, name: &str, phase: SandboxPhase) -> Sandbox { let mut sandbox = Sandbox { metadata: Some(openshell_core::proto::datamodel::v1::ObjectMeta { @@ -4889,25 +4800,15 @@ mod tests { #[test] fn main_process_exit_zero_is_terminal_error() { let mut sandbox = sandbox_record("sb-1", "sandbox-a", SandboxPhase::Ready); - apply_main_process_exit( - &mut sandbox, - &MainProcessExit { - generation: "generation-1".into(), - exit_code: Some(0), - signal: None, - started_at_ms: 10, - finished_at_ms: 20, - }, - ); + apply_main_process_exit(&mut sandbox, "instance-1", 0); assert_eq!( SandboxPhase::try_from(sandbox.phase()), Ok(SandboxPhase::Error) ); let status = sandbox.status.as_ref().unwrap(); - let main = status.main_process.as_ref().unwrap(); - assert_eq!(main.exit_code, Some(0)); - assert_eq!(main.state, MainProcessState::Exited as i32); + assert_eq!(status.exit_code, Some(0)); + assert_eq!(status.main_process_instance_id, "instance-1"); assert!(status.conditions.iter().any(|condition| { condition.r#type == "Ready" && condition.status == "False" @@ -4916,29 +4817,20 @@ mod tests { } #[tokio::test] - async fn stale_main_process_exit_cannot_replace_active_generation() { + async fn stale_main_process_exit_cannot_replace_active_instance() { let runtime = test_runtime(Arc::new(TestDriver::default())).await; let sandbox = sandbox_record("sb-1", "sandbox-a", SandboxPhase::Provisioning); runtime.store.put_message(&sandbox).await.unwrap(); runtime - .supervisor_session_connected("sb-1", "generation-2") + .supervisor_session_connected("sb-1", "instance-2") .await .unwrap(); let error = runtime - .main_process_exited( - "sb-1", - &MainProcessExit { - generation: "generation-1".into(), - exit_code: Some(0), - signal: None, - started_at_ms: 10, - finished_at_ms: 20, - }, - ) + .main_process_exited("sb-1", "instance-1", 0) .await .unwrap_err(); - assert!(error.contains("stale main-process exit generation")); + assert!(error.contains("stale main-process exit instance")); let stored = runtime .store .get_message::("sb-1") @@ -4947,8 +4839,8 @@ mod tests { .unwrap(); assert_eq!(stored.phase(), SandboxPhase::Ready as i32); assert_eq!( - stored.status.unwrap().main_process.unwrap().generation, - "generation-2" + stored.status.unwrap().main_process_instance_id, + "instance-2" ); } @@ -4958,19 +4850,17 @@ mod tests { let sandbox = sandbox_record("sb-1", "sandbox-a", SandboxPhase::Provisioning); runtime.store.put_message(&sandbox).await.unwrap(); runtime - .supervisor_session_connected("sb-1", "generation-1") + .supervisor_session_connected("sb-1", "instance-1") + .await + .unwrap(); + runtime + .main_process_exited("sb-1", "instance-1", 9) + .await + .unwrap(); + runtime + .main_process_exited("sb-1", "instance-1", 9) .await .unwrap(); - let exit = MainProcessExit { - generation: "generation-1".into(), - exit_code: Some(9), - signal: None, - started_at_ms: 10, - finished_at_ms: 20, - }; - - runtime.main_process_exited("sb-1", &exit).await.unwrap(); - runtime.main_process_exited("sb-1", &exit).await.unwrap(); let stored = runtime .store .get_message::("sb-1") @@ -4978,10 +4868,7 @@ mod tests { .unwrap() .unwrap(); assert_eq!(stored.phase(), SandboxPhase::Error as i32); - assert_eq!( - stored.status.unwrap().main_process.unwrap().exit_code, - Some(9) - ); + assert_eq!(stored.status.unwrap().exit_code, Some(9)); } #[tokio::test] @@ -4990,28 +4877,13 @@ mod tests { let mut sandbox = sandbox_record("sb-1", "sandbox-a", SandboxPhase::Error); sandbox.status = Some(SandboxStatus { phase: SandboxPhase::Error as i32, - main_process: Some(MainProcessStatus { - state: MainProcessState::Exited as i32, - generation: "generation-1".into(), - started_at_ms: 10, - finished_at_ms: 15, - ..Default::default() - }), + main_process_instance_id: "instance-1".into(), ..Default::default() }); runtime.store.put_message(&sandbox).await.unwrap(); runtime - .main_process_exited( - "sb-1", - &MainProcessExit { - generation: "generation-1".into(), - exit_code: Some(7), - signal: None, - started_at_ms: 10, - finished_at_ms: 20, - }, - ) + .main_process_exited("sb-1", "instance-1", 7) .await .unwrap(); @@ -5022,9 +4894,7 @@ mod tests { .unwrap() .unwrap(); assert_eq!(stored.phase(), SandboxPhase::Error as i32); - let main = stored.status.unwrap().main_process.unwrap(); - assert_eq!(main.exit_code, Some(7)); - assert_eq!(main.finished_at_ms, 20); + assert_eq!(stored.status.unwrap().exit_code, Some(7)); } #[tokio::test] @@ -5037,27 +4907,13 @@ mod tests { let mut sandbox = sandbox_record(id, id, phase); sandbox.status = Some(SandboxStatus { phase: phase as i32, - main_process: Some(MainProcessStatus { - state: MainProcessState::Running as i32, - generation: "generation-1".into(), - started_at_ms: 10, - ..Default::default() - }), + main_process_instance_id: "instance-1".into(), ..Default::default() }); runtime.store.put_message(&sandbox).await.unwrap(); runtime - .main_process_exited( - id, - &MainProcessExit { - generation: "generation-1".into(), - exit_code: None, - signal: Some(15), - started_at_ms: 10, - finished_at_ms: 20, - }, - ) + .main_process_exited(id, "instance-1", 143) .await .unwrap(); @@ -5068,10 +4924,7 @@ mod tests { .unwrap() .unwrap(); assert_eq!(stored.phase(), phase as i32); - assert_eq!( - stored.status.unwrap().main_process.unwrap().state, - MainProcessState::Running as i32 - ); + assert_eq!(stored.status.unwrap().exit_code, None); } } @@ -7556,12 +7409,7 @@ mod tests { let mut sandbox = sandbox_record("sb-1", "sandbox-a", SandboxPhase::Ready); sandbox.status = Some(SandboxStatus { sandbox_name: "sandbox-a".to_string(), - main_process: Some(MainProcessStatus { - state: MainProcessState::Running as i32, - generation: "generation-1".to_string(), - started_at_ms: 10, - ..Default::default() - }), + main_process_instance_id: "instance-1".to_string(), ..Default::default() }); runtime.store.put_message(&sandbox).await.unwrap(); @@ -7583,12 +7431,9 @@ mod tests { SandboxPhase::try_from(stored.phase()).unwrap(), SandboxPhase::Error ); - let main = stored.status.unwrap().main_process.unwrap(); - assert_eq!(main.state, MainProcessState::Exited as i32); - assert_eq!(main.generation, "generation-1"); - assert_eq!(main.started_at_ms, 10); - assert_eq!(main.exit_code, None); - assert_eq!(main.signal, None); + let status = stored.status.unwrap(); + assert_eq!(status.main_process_instance_id, "instance-1"); + assert_eq!(status.exit_code, None); } #[tokio::test] @@ -7949,7 +7794,7 @@ mod tests { SandboxPhase::Error ); assert!( - stored.status.unwrap().main_process.is_none(), + stored.status.unwrap().main_process_instance_id.is_empty(), "a provisioning failure must not fabricate a main-process exit" ); } diff --git a/crates/openshell-server/src/grpc/mod.rs b/crates/openshell-server/src/grpc/mod.rs index ba9e4f6d60..2f9b2a5ef5 100644 --- a/crates/openshell-server/src/grpc/mod.rs +++ b/crates/openshell-server/src/grpc/mod.rs @@ -43,14 +43,15 @@ use openshell_core::proto::{ ProviderProfileResponse, ProviderResponse, PushSandboxLogsRequest, PushSandboxLogsResponse, RefreshSandboxTokenRequest, RefreshSandboxTokenResponse, RejectDraftChunkRequest, RejectDraftChunkResponse, RelayFrame, RemoveWorkspaceMemberRequest, - RemoveWorkspaceMemberResponse, 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, + 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, }; use serde::{Deserialize, Serialize}; use std::collections::BTreeMap; @@ -253,7 +254,6 @@ impl OpenShell for OpenShellService { capabilities: Some(ComputeDriverCapabilities { driver_name: driver.driver_name.clone(), driver_version: driver.driver_version.clone(), - supports_main_process: driver.supports_main_process, }), }) .collect(); @@ -680,6 +680,13 @@ impl OpenShell for OpenShellService { crate::supervisor_session::handle_connect_supervisor(&self.state, request).await } + async fn report_main_process_exit( + &self, + request: Request, + ) -> Result, Status> { + crate::supervisor_session::handle_report_main_process_exit(&self.state, request).await + } + type RelayStreamStream = Pin> + Send + 'static>>; diff --git a/crates/openshell-server/src/grpc/sandbox.rs b/crates/openshell-server/src/grpc/sandbox.rs index f56ae99850..1cd1c4a0e6 100644 --- a/crates/openshell-server/src/grpc/sandbox.rs +++ b/crates/openshell-server/src/grpc/sandbox.rs @@ -22,10 +22,10 @@ use openshell_core::proto::{ DetachSandboxProviderRequest, DetachSandboxProviderResponse, ExecSandboxEvent, ExecSandboxExit, ExecSandboxInput, ExecSandboxRequest, ExecSandboxStderr, ExecSandboxStdout, GetSandboxRequest, ListSandboxProvidersRequest, ListSandboxProvidersResponse, ListSandboxesRequest, - ListSandboxesResponse, MainProcessSpec, Provider, RevokeSshSessionRequest, - RevokeSshSessionResponse, SandboxResponse, SandboxStreamEvent, SshRelayTarget, - StartSandboxRequest, StopSandboxRequest, TcpForwardFrame, TcpForwardInit, TcpRelayTarget, - WatchSandboxRequest, relay_open, tcp_forward_init, + ListSandboxesResponse, Provider, RevokeSshSessionRequest, RevokeSshSessionResponse, + SandboxResponse, SandboxStreamEvent, SshRelayTarget, StartSandboxRequest, StopSandboxRequest, + TcpForwardFrame, TcpForwardInit, TcpRelayTarget, WatchSandboxRequest, relay_open, + tcp_forward_init, }; use openshell_core::proto::{Sandbox, SandboxPhase, SandboxTemplate, SshSession}; use openshell_core::telemetry::{ @@ -224,11 +224,10 @@ async fn handle_create_sandbox_inner( // Every newly persisted sandbox has one explicit canonical process. This // portable default also preserves compatibility with callers compiled // before the main-process field was introduced. - spec.main_process.get_or_insert_with(|| MainProcessSpec { - command: vec!["/bin/bash".to_string(), "-l".to_string()], - terminal: true, - ..MainProcessSpec::default() - }); + if spec.command.is_empty() { + spec.command = vec!["/bin/bash".to_string(), "-l".to_string()]; + spec.tty = true; + } // Validate field sizes before any I/O (fail fast on oversized payloads). validate_sandbox_spec(&request.name, &spec)?; diff --git a/crates/openshell-server/src/grpc/validation.rs b/crates/openshell-server/src/grpc/validation.rs index 0beb33b0da..92dcaeb4fe 100644 --- a/crates/openshell-server/src/grpc/validation.rs +++ b/crates/openshell-server/src/grpc/validation.rs @@ -10,8 +10,8 @@ use openshell_core::ComputeDriverKind; use openshell_core::proto::{ - CredentialHandle, ExecSandboxRequest, MainProcessSpec, Provider, - SandboxPolicy as ProtoSandboxPolicy, SandboxTemplate, + CredentialHandle, ExecSandboxRequest, Provider, SandboxPolicy as ProtoSandboxPolicy, + SandboxTemplate, }; use prost::Message; use tonic::Status; @@ -216,9 +216,8 @@ pub(super) fn validate_sandbox_spec( // --- spec.resource_requirements.gpu --- validate_gpu_request_fields(spec)?; - // --- spec.main_process --- - if let Some(main_process) = spec.main_process.as_ref() { - validate_main_process_spec(main_process)?; + if !spec.command.is_empty() { + validate_main_process_command(&spec.command)?; } // --- spec.policy serialized size --- @@ -234,64 +233,32 @@ pub(super) fn validate_sandbox_spec( Ok(()) } -fn validate_main_process_spec(main_process: &MainProcessSpec) -> Result<(), Status> { - if main_process.command.is_empty() { - return Err(Status::invalid_argument( - "spec.main_process.command must not be empty", - )); - } - if main_process.command.len() > MAX_MAIN_PROCESS_ARGS { +fn validate_main_process_command(command: &[String]) -> Result<(), Status> { + if command.len() > MAX_MAIN_PROCESS_ARGS { return Err(Status::invalid_argument(format!( - "spec.main_process.command exceeds {MAX_MAIN_PROCESS_ARGS} argument limit" + "spec.command exceeds {MAX_MAIN_PROCESS_ARGS} argument limit" ))); } - if main_process.command[0].is_empty() { + if command[0].is_empty() { return Err(Status::invalid_argument( - "spec.main_process.command[0] must not be empty", + "spec.command[0] must not be empty", )); } - let argv_size: usize = main_process.command.iter().map(String::len).sum(); + let argv_size: usize = command.iter().map(String::len).sum(); if argv_size > MAX_MAIN_PROCESS_ARGV_SIZE { return Err(Status::invalid_argument(format!( - "spec.main_process.command total size exceeds {MAX_MAIN_PROCESS_ARGV_SIZE} byte limit" + "spec.command total size exceeds {MAX_MAIN_PROCESS_ARGV_SIZE} byte limit" ))); } - for (index, argument) in main_process.command.iter().enumerate() { + for (index, argument) in command.iter().enumerate() { if argument.len() > MAX_EXEC_ARG_LEN { return Err(Status::invalid_argument(format!( - "spec.main_process.command[{index}] exceeds {MAX_EXEC_ARG_LEN} byte limit" + "spec.command[{index}] exceeds {MAX_EXEC_ARG_LEN} byte limit" ))); } - reject_null_char(argument, &format!("spec.main_process.command[{index}]"))?; + reject_null_char(argument, &format!("spec.command[{index}]"))?; } - validate_string_map( - &main_process.environment, - MAX_ENVIRONMENT_ENTRIES, - MAX_MAP_KEY_LEN, - MAX_MAP_VALUE_LEN, - "spec.main_process.environment", - )?; - validate_env_entries(&main_process.environment, "spec.main_process.environment")?; - - let workdir = &main_process.working_directory; - if !workdir.is_empty() { - if workdir.len() > MAX_EXEC_WORKDIR_LEN { - return Err(Status::invalid_argument(format!( - "spec.main_process.working_directory exceeds {MAX_EXEC_WORKDIR_LEN} byte limit" - ))); - } - reject_control_chars(workdir, "spec.main_process.working_directory")?; - if !workdir.starts_with('/') - || workdir - .split('/') - .any(|component| component == "." || component == "..") - { - return Err(Status::invalid_argument( - "spec.main_process.working_directory must be an absolute normalized path", - )); - } - } Ok(()) } @@ -1093,43 +1060,13 @@ mod tests { #[test] fn validate_sandbox_spec_accepts_exact_main_process_argv() { let spec = SandboxSpec { - main_process: Some(MainProcessSpec { - command: vec!["/bin/sh".into(), "-c".into(), "printf 'a b'".into()], - working_directory: "/sandbox/work".into(), - terminal: false, - ..Default::default() - }), + command: vec!["/bin/sh".into(), "-c".into(), "printf 'a b'".into()], + tty: false, ..Default::default() }; validate_sandbox_spec("", &spec).unwrap(); } - #[test] - fn validate_sandbox_spec_rejects_empty_main_process_command() { - let spec = SandboxSpec { - main_process: Some(MainProcessSpec::default()), - ..Default::default() - }; - let error = validate_sandbox_spec("", &spec).unwrap_err(); - assert_eq!(error.code(), Code::InvalidArgument); - assert!(error.message().contains("main_process.command")); - } - - #[test] - fn validate_sandbox_spec_rejects_non_normal_main_process_workdir() { - let spec = SandboxSpec { - main_process: Some(MainProcessSpec { - command: vec!["/bin/true".into()], - working_directory: "/sandbox/../root".into(), - ..Default::default() - }), - ..Default::default() - }; - let error = validate_sandbox_spec("", &spec).unwrap_err(); - assert_eq!(error.code(), Code::InvalidArgument); - assert!(error.message().contains("absolute normalized path")); - } - #[test] fn validate_sandbox_spec_accepts_at_limit_name() { let name = "a".repeat(MAX_ROUTABLE_NAME_LEN); diff --git a/crates/openshell-server/src/supervisor_session.rs b/crates/openshell-server/src/supervisor_session.rs index 39a227ef82..748cf9d8bf 100644 --- a/crates/openshell-server/src/supervisor_session.rs +++ b/crates/openshell-server/src/supervisor_session.rs @@ -13,9 +13,9 @@ use tracing::{debug, info, warn}; use uuid::Uuid; use openshell_core::proto::{ - GatewayMessage, MainProcessExitAck, RelayFrame, RelayInit, RelayOpen, Sandbox, SandboxPhase, - SessionAccepted, SshRelayTarget, SupervisorMessage, gateway_message, relay_open, - supervisor_message, + GatewayMessage, RelayFrame, RelayInit, RelayOpen, ReportMainProcessExitRequest, + ReportMainProcessExitResponse, Sandbox, SandboxPhase, SessionAccepted, SshRelayTarget, + SupervisorMessage, gateway_message, relay_open, supervisor_message, }; use openshell_core::transport_errors::is_expected_transport_close_status; @@ -714,23 +714,15 @@ pub async fn handle_connect_supervisor( "supervisor session: accepted" ); - // Step 2: Create the outbound channel. Exit-report-only sessions are - // deliberately not registered: they must not supersede the live relay - // session or mutate sandbox readiness. + // Step 2: Create and register the outbound channel. let (tx, rx) = mpsc::channel::(64); let (shutdown_tx, shutdown_rx) = oneshot::channel::<()>(); - let mut exit_report_guard = None; - let superseded = if hello.exit_report_only { - exit_report_guard = Some(shutdown_tx); - false - } else { - state.supervisor_sessions.register( - sandbox_id.clone(), - session_id.clone(), - tx.clone(), - shutdown_tx, - ) - }; + let superseded = state.supervisor_sessions.register( + sandbox_id.clone(), + session_id.clone(), + tx.clone(), + shutdown_tx, + ); if superseded { info!( sandbox_id = %sandbox_id, @@ -762,28 +754,25 @@ pub async fn handle_connect_supervisor( .await; } - if !hello.exit_report_only { - if let Err(err) = state - .compute - .supervisor_session_connected(&sandbox_id, &hello.instance_id) - .await - { - warn!( - sandbox_id = %sandbox_id, - session_id = %session_id, - error = %err, - "supervisor session: failed to mark sandbox ready" - ); - } else { - state.telemetry.sandbox_session_connected(&sandbox_id); - } + if let Err(err) = state + .compute + .supervisor_session_connected(&sandbox_id, &hello.instance_id) + .await + { + warn!( + sandbox_id = %sandbox_id, + session_id = %session_id, + error = %err, + "supervisor session: failed to mark sandbox ready" + ); + } else { + state.telemetry.sandbox_session_connected(&sandbox_id); } // Step 4: Spawn the session loop that reads inbound messages. let state_clone = Arc::clone(state); let sandbox_id_clone = sandbox_id.clone(); tokio::spawn(async move { - let _exit_report_guard = exit_report_guard; run_session_loop( &state_clone, &sandbox_id_clone, @@ -793,10 +782,9 @@ pub async fn handle_connect_supervisor( shutdown_rx, ) .await; - let still_ours = !hello.exit_report_only - && state_clone - .supervisor_sessions - .remove_if_current(&sandbox_id_clone, &session_id); + let still_ours = state_clone + .supervisor_sessions + .remove_if_current(&sandbox_id_clone, &session_id); if still_ours { info!(sandbox_id = %sandbox_id_clone, session_id = %session_id, "supervisor session: ended"); state_clone @@ -828,6 +816,30 @@ pub async fn handle_connect_supervisor( Ok(Response::new(stream)) } +pub async fn handle_report_main_process_exit( + state: &Arc, + request: Request, +) -> Result, Status> { + let principal = request.extensions().get::().cloned(); + let report = request.into_inner(); + if report.sandbox_id.is_empty() { + return Err(Status::invalid_argument("sandbox_id is required")); + } + if report.instance_id.is_empty() { + return Err(Status::invalid_argument("instance_id is required")); + } + if let Some(principal) = principal.as_ref() { + crate::auth::guard::ensure_sandbox_principal_scope(principal, &report.sandbox_id)?; + } + require_persisted_sandbox(&state.store, &report.sandbox_id).await?; + state + .compute + .main_process_exited(&report.sandbox_id, &report.instance_id, report.exit_code) + .await + .map_err(Status::failed_precondition)?; + Ok(Response::new(ReportMainProcessExitResponse {})) +} + async fn run_session_loop( state: &Arc, sandbox_id: &str, @@ -850,7 +862,7 @@ async fn run_session_loop( msg = inbound.message() => { match msg { Ok(Some(msg)) => { - handle_supervisor_message(state, sandbox_id, session_id, tx, msg).await; + handle_supervisor_message(state, sandbox_id, session_id, msg); } Ok(None) => { info!(sandbox_id = %sandbox_id, session_id = %session_id, "supervisor session: stream closed by supervisor"); @@ -893,11 +905,10 @@ async fn run_session_loop( } } -async fn handle_supervisor_message( +fn handle_supervisor_message( state: &Arc, sandbox_id: &str, session_id: &str, - tx: &mpsc::Sender, msg: SupervisorMessage, ) { match msg.payload { @@ -935,29 +946,6 @@ async fn handle_supervisor_message( "supervisor session: relay closed by supervisor" ); } - Some(supervisor_message::Payload::MainProcessExit(exit)) => { - match state.compute.main_process_exited(sandbox_id, &exit).await { - Ok(()) => { - let _ = tx - .send(GatewayMessage { - payload: Some(gateway_message::Payload::MainProcessExitAck( - MainProcessExitAck { - generation: exit.generation, - }, - )), - }) - .await; - } - Err(error) => { - warn!( - sandbox_id, - session_id, - %error, - "supervisor session: failed to persist main-process exit" - ); - } - } - } _ => { warn!( sandbox_id = %sandbox_id, diff --git a/crates/openshell-server/src/test_support.rs b/crates/openshell-server/src/test_support.rs index b392dd0e23..f8124ded6c 100644 --- a/crates/openshell-server/src/test_support.rs +++ b/crates/openshell-server/src/test_support.rs @@ -241,7 +241,6 @@ impl ComputeDriver for FakeComputeDriver { driver_name: state.driver_name.clone(), driver_version: state.driver_version.clone(), default_image: state.default_image.clone(), - supports_main_process: true, } }); Ok(Response::new(response)) diff --git a/crates/openshell-server/tests/common/mod.rs b/crates/openshell-server/tests/common/mod.rs index a2df4755f0..13c4294c0b 100644 --- a/crates/openshell-server/tests/common/mod.rs +++ b/crates/openshell-server/tests/common/mod.rs @@ -52,6 +52,13 @@ pub struct TestOpenShell; #[tonic::async_trait] impl OpenShell for TestOpenShell { + async fn report_main_process_exit( + &self, + _request: tonic::Request, + ) -> Result, Status> { + Err(Status::unimplemented("not used by this test server")) + } + async fn get_current_user( &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 86c7354647..987d43ba4a 100644 --- a/crates/openshell-server/tests/supervisor_relay_integration.rs +++ b/crates/openshell-server/tests/supervisor_relay_integration.rs @@ -48,6 +48,13 @@ struct RelayGateway { #[tonic::async_trait] impl OpenShell for RelayGateway { + async fn report_main_process_exit( + &self, + _request: tonic::Request, + ) -> Result, Status> { + Err(Status::unimplemented("not used by this test server")) + } + async fn get_current_user( &self, _request: tonic::Request, diff --git a/crates/openshell-supervisor-process/src/run.rs b/crates/openshell-supervisor-process/src/run.rs index 47eec7cbfe..46070da308 100644 --- a/crates/openshell-supervisor-process/src/run.rs +++ b/crates/openshell-supervisor-process/src/run.rs @@ -13,7 +13,6 @@ use miette::{IntoDiagnostic, Result}; use std::sync::Arc; use std::sync::atomic::{AtomicBool, AtomicU32, Ordering}; use std::time::Duration; -use std::time::{SystemTime, UNIX_EPOCH}; use tokio::time::timeout; use tracing::info; @@ -41,7 +40,8 @@ use crate::process::{ }; pub type SidecarExitReport = ( - openshell_core::proto::MainProcessExit, + String, + i32, tokio::sync::oneshot::Sender>, ); @@ -258,8 +258,7 @@ pub async fn run_process( let main_pid = handle.pid(); let main_session = crate::main_session::MainSession::new(handle.take_io(), main_pid); - let main_generation = uuid::Uuid::new_v4().to_string(); - let main_started_at_ms = current_time_ms(); + let main_instance_id = uuid::Uuid::new_v4().to_string(); // SSH-spawned shells get http_proxy=http://: exported into // their env so cooperative tools (curl, npm, Node) route through the @@ -366,7 +365,7 @@ pub async fn run_process( ssh_netns_fd, None, Arc::clone(&supervisor_terminating), - main_generation.clone(), + main_instance_id.clone(), ); info!("supervisor session task spawned"); Some(task) @@ -379,7 +378,7 @@ pub async fn run_process( if early_exit.is_none() && let Some(tx) = entrypoint_started_tx { - let _ = tx.send((handle.pid(), main_generation.clone())); + let _ = tx.send((handle.pid(), main_instance_id.clone())); } ocsf_emit!( ProcessActivityBuilder::new(ocsf_ctx()) @@ -401,8 +400,8 @@ pub async fn run_process( .await? }; - let (exit_code, signal, rendered_code) = match outcome { - ProcessWaitOutcome::Exited(status) => (status.exit_code(), status.signal(), status.code()), + let rendered_code = match outcome { + ProcessWaitOutcome::Exited(status) => status.code(), ProcessWaitOutcome::TimedOut => { ocsf_emit!( ProcessActivityBuilder::new(ocsf_ctx()) @@ -414,7 +413,7 @@ pub async fn run_process( .message("Process timed out, killing") .build() ); - (Some(124), None, 124) + 124 } ProcessWaitOutcome::ShutdownSignal { signal, status } => { info!( @@ -422,7 +421,7 @@ pub async fn run_process( exit_code = status.code(), "Entrypoint exited after supervisor shutdown signal" ); - (status.exit_code(), status.signal(), status.code()) + status.code() } }; supervisor_terminating.store(true, Ordering::Release); @@ -443,16 +442,9 @@ pub async fn run_process( if let Some(task) = supervisor_session_task { task.abort(); } - let exit = openshell_core::proto::MainProcessExit { - generation: main_generation.clone(), - exit_code, - signal, - started_at_ms: main_started_at_ms, - finished_at_ms: current_time_ms(), - }; if let Some(tx) = sidecar_exit_tx { let (ack_tx, ack_rx) = tokio::sync::oneshot::channel(); - tx.send((exit, ack_tx)) + tx.send((main_instance_id.clone(), rendered_code, ack_tx)) .await .map_err(|_| miette::miette!("sidecar exit reporter closed"))?; ack_rx @@ -460,8 +452,8 @@ pub async fn run_process( .map_err(|_| miette::miette!("sidecar exit reporter dropped acknowledgement"))? .map_err(|error| miette::miette!(error))?; } else if let (Some(endpoint), Some(id)) = (openshell_endpoint, sandbox_id) { - report_main_process_exit_until_ack(endpoint, id, &main_generation, exit).await; - info!(generation = %main_generation, "main-process exit acknowledged"); + report_main_process_exit_until_ack(endpoint, id, &main_instance_id, rendered_code).await; + info!(instance_id = %main_instance_id, "main-process exit acknowledged"); } Ok(rendered_code) @@ -470,16 +462,16 @@ pub async fn run_process( async fn report_main_process_exit_until_ack( endpoint: &str, sandbox_id: &str, - generation: &str, - exit: openshell_core::proto::MainProcessExit, + instance_id: &str, + exit_code: i32, ) { let mut retry_delay = Duration::from_millis(250); loop { match crate::supervisor_session::report_main_process_exit( endpoint, sandbox_id, - generation, - exit.clone(), + instance_id, + exit_code, ) .await { @@ -493,14 +485,6 @@ async fn report_main_process_exit_until_ack( } } -fn current_time_ms() -> i64 { - SystemTime::now() - .duration_since(UNIX_EPOCH) - .map_or(0, |duration| { - i64::try_from(duration.as_millis()).unwrap_or(i64::MAX) - }) -} - enum ProcessWaitOutcome { Exited(ProcessStatus), TimedOut, diff --git a/crates/openshell-supervisor-process/src/supervisor_session.rs b/crates/openshell-supervisor-process/src/supervisor_session.rs index 84497b24fe..e8a140e483 100644 --- a/crates/openshell-supervisor-process/src/supervisor_session.rs +++ b/crates/openshell-supervisor-process/src/supervisor_session.rs @@ -19,9 +19,9 @@ use std::time::Duration; use openshell_core::proto::open_shell_client::OpenShellClient; use openshell_core::proto::{ - GatewayMessage, MainProcessExit, RelayFrame, RelayInit, RelayOpen, RelayOpenResult, - SupervisorHeartbeat, SupervisorHello, SupervisorMessage, TcpRelayTarget, gateway_message, - relay_open, supervisor_message, + GatewayMessage, RelayFrame, RelayInit, RelayOpen, RelayOpenResult, + ReportMainProcessExitRequest, SupervisorHeartbeat, SupervisorHello, SupervisorMessage, + TcpRelayTarget, gateway_message, relay_open, supervisor_message, }; use openshell_ocsf::{ ActivityId, ConnectionInfo, Endpoint, NetworkActivityBuilder, OcsfEvent, SandboxContext, @@ -368,7 +368,6 @@ async fn run_single_session( payload: Some(supervisor_message::Payload::Hello(SupervisorHello { sandbox_id: sandbox_id.to_string(), instance_id: instance_id.to_string(), - exit_report_only: false, })), }) .await @@ -448,54 +447,25 @@ async fn run_single_session( } } -/// Report the canonical process result on a short-lived authenticated session -/// and wait until the gateway acknowledges durable handling. +/// Report the canonical process result and wait for durable handling. pub async fn report_main_process_exit( endpoint: &str, sandbox_id: &str, instance_id: &str, - exit: MainProcessExit, + exit_code: i32, ) -> Result<(), Box> { let channel = grpc_client::connect_channel_pub(endpoint) .await .map_err(|error| format!("connect failed: {error}"))?; let mut client = OpenShellClient::new(channel); - let (tx, rx) = mpsc::channel::(4); - tx.send(SupervisorMessage { - payload: Some(supervisor_message::Payload::Hello(SupervisorHello { + client + .report_main_process_exit(ReportMainProcessExitRequest { sandbox_id: sandbox_id.to_string(), instance_id: instance_id.to_string(), - exit_report_only: true, - })), - }) - .await - .map_err(|_| "failed to queue supervisor hello")?; - let response = client - .connect_supervisor(tokio_stream::wrappers::ReceiverStream::new(rx)) + exit_code, + }) .await?; - let mut inbound = response.into_inner(); - let accepted = inbound - .message() - .await? - .and_then(|message| message.payload) - .is_some_and(|payload| matches!(payload, gateway_message::Payload::SessionAccepted(_))); - if !accepted { - return Err("gateway did not accept exit-report session".into()); - } - let generation = exit.generation.clone(); - tx.send(SupervisorMessage { - payload: Some(supervisor_message::Payload::MainProcessExit(exit)), - }) - .await - .map_err(|_| "failed to queue main-process exit")?; - while let Some(message) = inbound.message().await? { - if let Some(gateway_message::Payload::MainProcessExitAck(ack)) = message.payload - && ack.generation == generation - { - return Ok(()); - } - } - Err("gateway closed before acknowledging main-process exit".into()) + Ok(()) } struct GatewayMessageContext<'a> { diff --git a/docs/sandboxes/manage-sandboxes.mdx b/docs/sandboxes/manage-sandboxes.mdx index 27a8b6d705..b03ebc698d 100644 --- a/docs/sandboxes/manage-sandboxes.mdx +++ b/docs/sandboxes/manage-sandboxes.mdx @@ -163,7 +163,7 @@ openshell sandbox connect my-sandbox ``` Disconnecting does not stop the process or close its stdin. A later `connect` -attaches to the same process generation and replays up to 1 MiB of recent +attaches to the same process instance and replays up to 1 MiB of recent output. One attachment owns stdin at a time. Use `sandbox exec --tty -- /bin/bash -l` when you want a new independent shell instead. @@ -507,7 +507,9 @@ temporarily while its supervisor reconnects. Wait for the phase to return to `Ready` before you connect to the sandbox or execute commands. The gateway records a canonical main-process exit as `Ready=False` with reason -`MainProcessExited`. Compute runtimes do not automatically restart that process. +`MainProcessExited`. It also sets `status.exit_code`; signal exits use the +standard `128 + signal` convention. Compute runtimes do not automatically +restart that process. ## Sandbox Compute Drivers diff --git a/proto/compute_driver.proto b/proto/compute_driver.proto index 66254ea22b..5fe633a584 100644 --- a/proto/compute_driver.proto +++ b/proto/compute_driver.proto @@ -72,10 +72,6 @@ message GetCapabilitiesResponse { string driver_version = 2; // Default sandbox image recommended by the driver. string default_image = 3; - // Whether the driver forwards the exact canonical main-process contract. - // Gateways reject creation when this is false so older external drivers - // cannot silently substitute their legacy idle entrypoint. - bool supports_main_process = 6; } message GetGatewayListenerRequirementsRequest {} @@ -146,16 +142,10 @@ message DriverSandboxSpec { // ServiceAccount token bootstrap instead). Never echoed to the public // Sandbox proto. string sandbox_token = 11 [(openshell.options.v1.secret) = true]; - // Exact canonical process specification forwarded to the supervisor. - MainProcessSpec main_process = 12; -} - -// Exact, shell-free specification for the canonical main process. -message MainProcessSpec { - repeated string command = 1; - map environment = 2; - string working_directory = 3; - bool terminal = 4; + // Exact canonical command forwarded to the supervisor without shell parsing. + repeated string command = 12; + // Allocate a retained pseudo-terminal for the canonical process. + bool tty = 13; } message ResourceRequirements { diff --git a/proto/openshell.proto b/proto/openshell.proto index 7ec9716e18..800da9e451 100644 --- a/proto/openshell.proto +++ b/proto/openshell.proto @@ -455,6 +455,13 @@ service OpenShell { }; } + // Persist the canonical main process result before the supervisor exits. + rpc ReportMainProcessExit(ReportMainProcessExitRequest) returns (ReportMainProcessExitResponse) { + option (openshell.options.v1.authorization) = { + auth_mode: "sandbox" + }; + } + // Raw byte relay between supervisor and gateway. // // The supervisor initiates this call after receiving a RelayOpen message @@ -773,8 +780,6 @@ message ComputeDriverCapabilities { // Driver-reported implementation version from the startup capability snapshot. string driver_version = 2; - // Whether the driver can launch the exact canonical main-process contract. - bool supports_main_process = 3; } // Public sandbox resource exposed by the OpenShell API. @@ -820,22 +825,12 @@ message SandboxSpec { // managed fleet-wide. reserved 11; reserved "proposal_approval_mode"; - // Canonical process launched once by the sandbox supervisor. The gateway - // normalizes an omitted value to the portable scratch login shell before - // persisting a newly-created sandbox. - MainProcessSpec main_process = 12; -} - -// Exact, shell-free specification for the sandbox's canonical main process. -message MainProcessSpec { - // Executable followed by its arguments. No shell parsing is performed. - repeated string command = 1; - // Non-secret environment overrides applied only to the main process. - map environment = 2; - // Optional absolute working directory inside the sandbox. - string working_directory = 3; + // Canonical command launched once by the sandbox supervisor. No shell + // parsing is performed. The gateway normalizes an omitted command to the + // portable scratch login shell before persistence. + repeated string command = 12; // Allocate a retained pseudo-terminal for the main process. - bool terminal = 4; + bool tty = 13; } message ResourceRequirements { @@ -899,26 +894,12 @@ message SandboxStatus { SandboxPhase phase = 6; // Currently active policy version (updated when sandbox reports loaded). uint32 current_policy_version = 7; - // Last observed state of the canonical main process. - MainProcessStatus main_process = 8; -} - -// Lifecycle state of the canonical main process. -enum MainProcessState { - MAIN_PROCESS_STATE_UNSPECIFIED = 0; - MAIN_PROCESS_STATE_RUNNING = 1; - MAIN_PROCESS_STATE_EXITED = 2; -} - -// Persisted result for the canonical main-process generation. -message MainProcessStatus { - MainProcessState state = 1; - // Supervisor instance identifier used to reject stale exit reports. - string generation = 2; - optional int32 exit_code = 3; - optional int32 signal = 4; - int64 started_at_ms = 5; - int64 finished_at_ms = 6; + // Supervisor instance currently associated with the canonical main process. + // The gateway uses this to reject stale exit reports after a restart. + string main_process_instance_id = 8; + // Normalized main process result. Signal exits use 128 + signal number. + // Presence indicates that the main process exited and the sandbox is in Error. + optional int32 exit_code = 9; } // User-facing sandbox condition derived from driver-native conditions. @@ -2102,7 +2083,6 @@ message SupervisorMessage { SupervisorHeartbeat heartbeat = 2; RelayOpenResult relay_open_result = 3; RelayClose relay_close = 4; - MainProcessExit main_process_exit = 5; } } @@ -2114,7 +2094,6 @@ message GatewayMessage { GatewayHeartbeat heartbeat = 3; RelayOpen relay_open = 4; RelayClose relay_close = 5; - MainProcessExitAck main_process_exit_ack = 6; } } @@ -2124,9 +2103,6 @@ message SupervisorHello { string sandbox_id = 1; // Supervisor instance ID (e.g. boot id or process epoch). string instance_id = 2; - // Short-lived terminal-result sessions authenticate an existing generation - // but must not replace the active relay session or advertise readiness. - bool exit_report_only = 3; } // Gateway accepts the supervisor session. @@ -2149,20 +2125,16 @@ message SupervisorHeartbeat {} // Gateway heartbeat. message GatewayHeartbeat {} -// Terminal result reported before the supervisor shuts down. A missing exit -// code with a present signal represents signal termination. -message MainProcessExit { - string generation = 1; - optional int32 exit_code = 2; - optional int32 signal = 3; - int64 started_at_ms = 4; - int64 finished_at_ms = 5; +// Terminal result reported before the supervisor shuts down. A successful RPC +// response confirms that the result was durably handled by the gateway. +message ReportMainProcessExitRequest { + string sandbox_id = 1; + string instance_id = 2; + // Normalized process result. Signal exits use 128 + signal number. + int32 exit_code = 3; } -// Gateway acknowledgement that the terminal result has been durably handled. -message MainProcessExitAck { - string generation = 1; -} +message ReportMainProcessExitResponse {} // Gateway requests the supervisor to open a relay channel. // diff --git a/python/openshell/_proto/__init__.py b/python/openshell/_proto/__init__.py index 41115e87dc..ee4cf2db8b 100644 --- a/python/openshell/_proto/__init__.py +++ b/python/openshell/_proto/__init__.py @@ -3,8 +3,6 @@ # Sandbox messages and phase enums moved into openshell.proto. Keep aliases on # datamodel_pb2 so existing Python callers and E2E tests continue to work. for _name in ( - "MainProcessSpec", - "MainProcessStatus", "Sandbox", "SandboxSpec", "SandboxTemplate", diff --git a/python/openshell/sandbox.py b/python/openshell/sandbox.py index e2dcc8683f..0e20e61024 100644 --- a/python/openshell/sandbox.py +++ b/python/openshell/sandbox.py @@ -126,21 +126,12 @@ def _normalize_bearer( return lambda: token -@dataclass(frozen=True) -class MainProcessStatusRef: - state: int - generation: str - exit_code: int | None - signal: int | None - started_at_ms: int - finished_at_ms: int - - @dataclass(frozen=True) class SandboxStatusRef: phase: int current_policy_version: int - main_process: MainProcessStatusRef | None = None + main_process_instance_id: str | None = None + exit_code: int | None = None class _ImmutableLabels(dict[str, str]): @@ -1096,11 +1087,6 @@ def _serialize_python_callable( def _sandbox_ref(sandbox: openshell_pb2.Sandbox) -> SandboxRef: status = sandbox.status if sandbox.HasField("status") else None - main = ( - status.main_process - if status is not None and status.HasField("main_process") - else None - ) return SandboxRef( id=sandbox.metadata.id if sandbox.metadata else "", name=sandbox.metadata.name if sandbox.metadata else "", @@ -1108,18 +1094,12 @@ def _sandbox_ref(sandbox: openshell_pb2.Sandbox) -> SandboxRef: status=SandboxStatusRef( phase=status.phase if status else 0, current_policy_version=status.current_policy_version if status else 0, - main_process=( - MainProcessStatusRef( - state=main.state, - generation=main.generation, - exit_code=main.exit_code if main.HasField("exit_code") else None, - signal=main.signal if main.HasField("signal") else None, - started_at_ms=main.started_at_ms, - finished_at_ms=main.finished_at_ms, - ) - if main is not None - else None - ), + main_process_instance_id=(status.main_process_instance_id or None) + if status + else None, + exit_code=status.exit_code + if status is not None and status.HasField("exit_code") + else None, ), labels=sandbox.metadata.labels if sandbox.metadata else {}, ) diff --git a/python/openshell/sandbox_test.py b/python/openshell/sandbox_test.py index 28df327a53..99246aa1c1 100644 --- a/python/openshell/sandbox_test.py +++ b/python/openshell/sandbox_test.py @@ -1774,21 +1774,13 @@ def test_sandbox_ref_retains_gateway_labels() -> None: def test_sandbox_ref_includes_main_process_result() -> None: proto = _make_sandbox_proto("sandbox-1", "job-1") - proto.status.main_process.state = openshell_pb2.MAIN_PROCESS_STATE_EXITED - proto.status.main_process.generation = "generation-1" - proto.status.main_process.exit_code = 0 - proto.status.main_process.started_at_ms = 10 - proto.status.main_process.finished_at_ms = 20 - - main = _sandbox_ref(proto).status.main_process - - assert main is not None - assert main.state == openshell_pb2.MAIN_PROCESS_STATE_EXITED - assert main.generation == "generation-1" - assert main.exit_code == 0 - assert main.signal is None - assert main.started_at_ms == 10 - assert main.finished_at_ms == 20 + proto.status.main_process_instance_id = "instance-1" + proto.status.exit_code = 0 + + status = _sandbox_ref(proto).status + + assert status.main_process_instance_id == "instance-1" + assert status.exit_code == 0 def test_returned_labels_are_immutable() -> None: diff --git a/sdk/go/openshell/v1/internal/converter/coverage_test.go b/sdk/go/openshell/v1/internal/converter/coverage_test.go index 0f6c3d5c5f..eed0b8731a 100644 --- a/sdk/go/openshell/v1/internal/converter/coverage_test.go +++ b/sdk/go/openshell/v1/internal/converter/coverage_test.go @@ -29,7 +29,8 @@ func TestConverterCoversAllProtoFields_SandboxSpec(t *testing.T) { "policy": true, "providers": true, "resource_requirements": true, - "main_process": true, + "command": true, + "tty": true, } assertAllFieldsCovered(t, (&pb.SandboxSpec{}).ProtoReflect().Descriptor(), handled, nil) @@ -53,14 +54,15 @@ func TestConverterCoversAllProtoFields_SandboxTemplate(t *testing.T) { func TestConverterCoversAllProtoFields_SandboxStatus(t *testing.T) { handled := fieldSet{ - "sandbox_name": true, - "agent_pod": true, - "agent_fd": true, - "sandbox_fd": true, - "phase": true, - "conditions": true, - "current_policy_version": true, - "main_process": true, + "sandbox_name": true, + "agent_pod": true, + "agent_fd": true, + "sandbox_fd": true, + "phase": true, + "conditions": true, + "current_policy_version": true, + "main_process_instance_id": true, + "exit_code": true, } assertAllFieldsCovered(t, (&pb.SandboxStatus{}).ProtoReflect().Descriptor(), handled, nil) diff --git a/sdk/go/openshell/v1/internal/converter/sandbox.go b/sdk/go/openshell/v1/internal/converter/sandbox.go index 37d6603bb8..ffcdb7d188 100644 --- a/sdk/go/openshell/v1/internal/converter/sandbox.go +++ b/sdk/go/openshell/v1/internal/converter/sandbox.go @@ -76,14 +76,8 @@ func sandboxSpecFromProto(spec *pb.SandboxSpec) types.SandboxSpec { result.GPUCount = gpu.Count } } - if main := spec.GetMainProcess(); main != nil { - result.MainProcess = &types.MainProcessSpec{ - Command: CopyStringSlice(main.GetCommand()), - Environment: CopyStringMap(main.GetEnvironment()), - WorkingDirectory: main.GetWorkingDirectory(), - Terminal: main.GetTerminal(), - } - } + result.Command = CopyStringSlice(spec.GetCommand()) + result.TTY = spec.GetTty() return result } @@ -107,16 +101,8 @@ func sandboxStatusFromProto(status *pb.SandboxStatus) types.SandboxStatus { LastTransitionTime: c.GetLastTransitionTime(), }) } - if main := status.GetMainProcess(); main != nil { - result.MainProcess = &types.MainProcessStatus{ - State: int32(main.GetState()), - Generation: main.GetGeneration(), - ExitCode: CopyInt32Ptr(main.ExitCode), - Signal: CopyInt32Ptr(main.Signal), - StartedAt: TimeFromMillis(main.GetStartedAtMs()), - FinishedAt: TimeFromMillis(main.GetFinishedAtMs()), - } - } + result.MainProcessInstanceID = status.GetMainProcessInstanceId() + result.ExitCode = CopyInt32Ptr(status.ExitCode) return result } @@ -238,14 +224,8 @@ func SandboxSpecToProto(spec *types.SandboxSpec) *pb.SandboxSpec { } } - if spec.MainProcess != nil { - result.MainProcess = &pb.MainProcessSpec{ - Command: CopyStringSlice(spec.MainProcess.Command), - Environment: CopyStringMap(spec.MainProcess.Environment), - WorkingDirectory: spec.MainProcess.WorkingDirectory, - Terminal: spec.MainProcess.Terminal, - } - } + result.Command = CopyStringSlice(spec.Command) + result.Tty = spec.TTY return result } diff --git a/sdk/go/openshell/v1/internal/converter/sandbox_test.go b/sdk/go/openshell/v1/internal/converter/sandbox_test.go index 7013fee585..0e1151cfc1 100644 --- a/sdk/go/openshell/v1/internal/converter/sandbox_test.go +++ b/sdk/go/openshell/v1/internal/converter/sandbox_test.go @@ -57,27 +57,18 @@ func TestSandboxFromProto(t *testing.T) { Count: &gpuCount, }, }, - MainProcess: &pb.MainProcessSpec{ - Command: []string{"/opt/agent", "--serve"}, - Environment: map[string]string{"MODE": "worker"}, - WorkingDirectory: "/sandbox/app", - Terminal: false, - }, + Command: []string{"/opt/agent", "--serve"}, + Tty: false, }, Status: &pb.SandboxStatus{ - SandboxName: "sb-compute-1", - AgentPod: "agent-pod-xyz", - AgentFd: "fd-agent", - SandboxFd: "fd-sandbox", - Phase: pb.SandboxPhase_SANDBOX_PHASE_READY, - CurrentPolicyVersion: 7, - MainProcess: &pb.MainProcessStatus{ - State: pb.MainProcessState_MAIN_PROCESS_STATE_EXITED, - Generation: "generation-1", - ExitCode: &exitCode, - StartedAtMs: 1700000001000, - FinishedAtMs: 1700000002000, - }, + SandboxName: "sb-compute-1", + AgentPod: "agent-pod-xyz", + AgentFd: "fd-agent", + SandboxFd: "fd-sandbox", + Phase: pb.SandboxPhase_SANDBOX_PHASE_READY, + CurrentPolicyVersion: 7, + MainProcessInstanceId: "instance-1", + ExitCode: &exitCode, Conditions: []*pb.SandboxCondition{ { Type: "Ready", @@ -109,11 +100,8 @@ func TestSandboxFromProto(t *testing.T) { assert.Equal(t, []string{"claude", "github"}, s.Spec.Providers) require.NotNil(t, s.Spec.GPUCount) assert.Equal(t, uint32(2), *s.Spec.GPUCount) - require.NotNil(t, s.Spec.MainProcess) - assert.Equal(t, []string{"/opt/agent", "--serve"}, s.Spec.MainProcess.Command) - assert.Equal(t, map[string]string{"MODE": "worker"}, s.Spec.MainProcess.Environment) - assert.Equal(t, "/sandbox/app", s.Spec.MainProcess.WorkingDirectory) - assert.False(t, s.Spec.MainProcess.Terminal) + assert.Equal(t, []string{"/opt/agent", "--serve"}, s.Spec.Command) + assert.False(t, s.Spec.TTY) // Template require.NotNil(t, s.Spec.Template) @@ -144,14 +132,9 @@ func TestSandboxFromProto(t *testing.T) { assert.Equal(t, "AllGood", s.Status.Conditions[0].Reason) assert.Equal(t, "Sandbox is ready", s.Status.Conditions[0].Message) assert.Equal(t, "2024-01-01T00:00:00Z", s.Status.Conditions[0].LastTransitionTime) - require.NotNil(t, s.Status.MainProcess) - assert.Equal(t, int32(pb.MainProcessState_MAIN_PROCESS_STATE_EXITED), s.Status.MainProcess.State) - assert.Equal(t, "generation-1", s.Status.MainProcess.Generation) - require.NotNil(t, s.Status.MainProcess.ExitCode) - assert.Equal(t, int32(0), *s.Status.MainProcess.ExitCode) - assert.Nil(t, s.Status.MainProcess.Signal) - assert.Equal(t, time.UnixMilli(1700000001000).UTC(), s.Status.MainProcess.StartedAt) - assert.Equal(t, time.UnixMilli(1700000002000).UTC(), s.Status.MainProcess.FinishedAt) + assert.Equal(t, "instance-1", s.Status.MainProcessInstanceID) + require.NotNil(t, s.Status.ExitCode) + assert.Equal(t, int32(0), *s.Status.ExitCode) } func TestSandboxFromProto_TemplateResourcesDeepCopy(t *testing.T) { @@ -270,12 +253,8 @@ func TestSandboxToProto(t *testing.T) { }, Providers: []string{"prov-a"}, GPUCount: &gpuCount, - MainProcess: &v1.MainProcessSpec{ - Command: []string{"/opt/agent", "--serve"}, - Environment: map[string]string{"MODE": "worker"}, - WorkingDirectory: "/sandbox/app", - Terminal: false, - }, + Command: []string{"/opt/agent", "--serve"}, + TTY: false, }, } @@ -296,11 +275,8 @@ func TestSandboxToProto(t *testing.T) { assert.Equal(t, "info", p.Spec.LogLevel) assert.Equal(t, map[string]string{"KEY": "val"}, p.Spec.Environment) assert.Equal(t, []string{"prov-a"}, p.Spec.Providers) - require.NotNil(t, p.Spec.MainProcess) - assert.Equal(t, []string{"/opt/agent", "--serve"}, p.Spec.MainProcess.Command) - assert.Equal(t, map[string]string{"MODE": "worker"}, p.Spec.MainProcess.Environment) - assert.Equal(t, "/sandbox/app", p.Spec.MainProcess.WorkingDirectory) - assert.False(t, p.Spec.MainProcess.Terminal) + assert.Equal(t, []string{"/opt/agent", "--serve"}, p.Spec.Command) + assert.False(t, p.Spec.Tty) require.NotNil(t, p.Spec.ResourceRequirements) require.NotNil(t, p.Spec.ResourceRequirements.Gpu) diff --git a/sdk/go/openshell/v1/types/sandbox.go b/sdk/go/openshell/v1/types/sandbox.go index 4c4e88b850..3ae61246c9 100644 --- a/sdk/go/openshell/v1/types/sandbox.go +++ b/sdk/go/openshell/v1/types/sandbox.go @@ -27,16 +27,9 @@ type SandboxSpec struct { Providers []string GPUCount *uint32 // Policy is the security policy for the sandbox. Nil means no policy specified. - Policy *SandboxPolicy - MainProcess *MainProcessSpec -} - -// MainProcessSpec is the exact canonical process launched once per sandbox. -type MainProcessSpec struct { - Command []string - Environment map[string]string - WorkingDirectory string - Terminal bool + Policy *SandboxPolicy + Command []string + TTY bool } // SandboxTemplate defines the container template for a sandbox. @@ -54,24 +47,15 @@ type SandboxTemplate struct { // SandboxStatus holds the observed state of a sandbox. type SandboxStatus struct { - SandboxName string - AgentPod string - AgentFd string - SandboxFd string - Phase SandboxPhase - Conditions []SandboxCondition - CurrentPolicyVersion uint32 - MainProcess *MainProcessStatus -} - -// MainProcessStatus records the active or terminal canonical-process generation. -type MainProcessStatus struct { - State int32 - Generation string - ExitCode *int32 - Signal *int32 - StartedAt time.Time - FinishedAt time.Time + SandboxName string + AgentPod string + AgentFd string + SandboxFd string + Phase SandboxPhase + Conditions []SandboxCondition + CurrentPolicyVersion uint32 + MainProcessInstanceID string + ExitCode *int32 } // SandboxCondition describes an observed condition of a sandbox. diff --git a/sdk/go/proto/openshellv1/openshell.pb.go b/sdk/go/proto/openshellv1/openshell.pb.go index 98fe2ccd3c..da001ae16c 100644 --- a/sdk/go/proto/openshellv1/openshell.pb.go +++ b/sdk/go/proto/openshellv1/openshell.pb.go @@ -28,56 +28,6 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) -// Lifecycle state of the canonical main process. -type MainProcessState int32 - -const ( - MainProcessState_MAIN_PROCESS_STATE_UNSPECIFIED MainProcessState = 0 - MainProcessState_MAIN_PROCESS_STATE_RUNNING MainProcessState = 1 - MainProcessState_MAIN_PROCESS_STATE_EXITED MainProcessState = 2 -) - -// Enum value maps for MainProcessState. -var ( - MainProcessState_name = map[int32]string{ - 0: "MAIN_PROCESS_STATE_UNSPECIFIED", - 1: "MAIN_PROCESS_STATE_RUNNING", - 2: "MAIN_PROCESS_STATE_EXITED", - } - MainProcessState_value = map[string]int32{ - "MAIN_PROCESS_STATE_UNSPECIFIED": 0, - "MAIN_PROCESS_STATE_RUNNING": 1, - "MAIN_PROCESS_STATE_EXITED": 2, - } -) - -func (x MainProcessState) Enum() *MainProcessState { - p := new(MainProcessState) - *p = x - return p -} - -func (x MainProcessState) String() string { - return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) -} - -func (MainProcessState) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[0].Descriptor() -} - -func (MainProcessState) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[0] -} - -func (x MainProcessState) Number() protoreflect.EnumNumber { - return protoreflect.EnumNumber(x) -} - -// Deprecated: Use MainProcessState.Descriptor instead. -func (MainProcessState) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{0} -} - // High-level sandbox lifecycle phase derived by the gateway. // // Clients should rely on this normalized lifecycle summary for readiness and @@ -133,11 +83,11 @@ func (x SandboxPhase) String() string { } func (SandboxPhase) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[1].Descriptor() + return file_openshell_proto_enumTypes[0].Descriptor() } func (SandboxPhase) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[1] + return &file_openshell_proto_enumTypes[0] } func (x SandboxPhase) Number() protoreflect.EnumNumber { @@ -146,7 +96,7 @@ func (x SandboxPhase) Number() protoreflect.EnumNumber { // Deprecated: Use SandboxPhase.Descriptor instead. func (SandboxPhase) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{1} + return file_openshell_proto_rawDescGZIP(), []int{0} } type ProviderCredentialRefreshStrategy int32 @@ -194,11 +144,11 @@ func (x ProviderCredentialRefreshStrategy) String() string { } func (ProviderCredentialRefreshStrategy) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[2].Descriptor() + return file_openshell_proto_enumTypes[1].Descriptor() } func (ProviderCredentialRefreshStrategy) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[2] + return &file_openshell_proto_enumTypes[1] } func (x ProviderCredentialRefreshStrategy) Number() protoreflect.EnumNumber { @@ -207,7 +157,7 @@ func (x ProviderCredentialRefreshStrategy) Number() protoreflect.EnumNumber { // Deprecated: Use ProviderCredentialRefreshStrategy.Descriptor instead. func (ProviderCredentialRefreshStrategy) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{2} + return file_openshell_proto_rawDescGZIP(), []int{1} } // Stable provider profile categories used by clients for grouping and filtering. @@ -259,11 +209,11 @@ func (x ProviderProfileCategory) String() string { } func (ProviderProfileCategory) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[3].Descriptor() + return file_openshell_proto_enumTypes[2].Descriptor() } func (ProviderProfileCategory) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[3] + return &file_openshell_proto_enumTypes[2] } func (x ProviderProfileCategory) Number() protoreflect.EnumNumber { @@ -272,7 +222,7 @@ func (x ProviderProfileCategory) Number() protoreflect.EnumNumber { // Deprecated: Use ProviderProfileCategory.Descriptor instead. func (ProviderProfileCategory) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{3} + return file_openshell_proto_rawDescGZIP(), []int{2} } // Policy load status. @@ -319,11 +269,11 @@ func (x PolicyStatus) String() string { } func (PolicyStatus) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[4].Descriptor() + return file_openshell_proto_enumTypes[3].Descriptor() } func (PolicyStatus) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[4] + return &file_openshell_proto_enumTypes[3] } func (x PolicyStatus) Number() protoreflect.EnumNumber { @@ -332,7 +282,7 @@ func (x PolicyStatus) Number() protoreflect.EnumNumber { // Deprecated: Use PolicyStatus.Descriptor instead. func (PolicyStatus) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{4} + return file_openshell_proto_rawDescGZIP(), []int{3} } // Service status enum. @@ -372,11 +322,11 @@ func (x ServiceStatus) String() string { } func (ServiceStatus) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[5].Descriptor() + return file_openshell_proto_enumTypes[4].Descriptor() } func (ServiceStatus) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[5] + return &file_openshell_proto_enumTypes[4] } func (x ServiceStatus) Number() protoreflect.EnumNumber { @@ -385,7 +335,7 @@ func (x ServiceStatus) Number() protoreflect.EnumNumber { // Deprecated: Use ServiceStatus.Descriptor instead. func (ServiceStatus) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{5} + return file_openshell_proto_rawDescGZIP(), []int{4} } // Workspace-scoped role for members. @@ -422,11 +372,11 @@ func (x WorkspaceRole) String() string { } func (WorkspaceRole) Descriptor() protoreflect.EnumDescriptor { - return file_openshell_proto_enumTypes[6].Descriptor() + return file_openshell_proto_enumTypes[5].Descriptor() } func (WorkspaceRole) Type() protoreflect.EnumType { - return &file_openshell_proto_enumTypes[6] + return &file_openshell_proto_enumTypes[5] } func (x WorkspaceRole) Number() protoreflect.EnumNumber { @@ -435,7 +385,7 @@ func (x WorkspaceRole) Number() protoreflect.EnumNumber { // Deprecated: Use WorkspaceRole.Descriptor instead. func (WorkspaceRole) EnumDescriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{6} + return file_openshell_proto_rawDescGZIP(), []int{5} } // IssueSandboxToken request. Empty body; identity is established by the @@ -1028,10 +978,8 @@ type ComputeDriverCapabilities struct { DriverName string `protobuf:"bytes,1,opt,name=driver_name,json=driverName,proto3" json:"driver_name,omitempty"` // Driver-reported implementation version from the startup capability snapshot. DriverVersion string `protobuf:"bytes,2,opt,name=driver_version,json=driverVersion,proto3" json:"driver_version,omitempty"` - // Whether the driver can launch the exact canonical main-process contract. - SupportsMainProcess bool `protobuf:"varint,3,opt,name=supports_main_process,json=supportsMainProcess,proto3" json:"supports_main_process,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *ComputeDriverCapabilities) Reset() { @@ -1078,13 +1026,6 @@ func (x *ComputeDriverCapabilities) GetDriverVersion() string { return "" } -func (x *ComputeDriverCapabilities) GetSupportsMainProcess() bool { - if x != nil { - return x.SupportsMainProcess - } - return false -} - // Public sandbox resource exposed by the OpenShell API. // // This is the canonical gateway-owned view of a sandbox. It merges user intent @@ -1172,10 +1113,12 @@ type SandboxSpec struct { // Portable resource requirements used by the gateway for driver selection // and by drivers for provisioning. ResourceRequirements *ResourceRequirements `protobuf:"bytes,9,opt,name=resource_requirements,json=resourceRequirements,proto3" json:"resource_requirements,omitempty"` - // Canonical process launched once by the sandbox supervisor. The gateway - // normalizes an omitted value to the portable scratch login shell before - // persisting a newly-created sandbox. - MainProcess *MainProcessSpec `protobuf:"bytes,12,opt,name=main_process,json=mainProcess,proto3" json:"main_process,omitempty"` + // Canonical command launched once by the sandbox supervisor. No shell + // parsing is performed. The gateway normalizes an omitted command to the + // portable scratch login shell before persistence. + Command []string `protobuf:"bytes,12,rep,name=command,proto3" json:"command,omitempty"` + // Allocate a retained pseudo-terminal for the main process. + Tty bool `protobuf:"varint,13,opt,name=tty,proto3" json:"tty,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } @@ -1252,82 +1195,16 @@ func (x *SandboxSpec) GetResourceRequirements() *ResourceRequirements { return nil } -func (x *SandboxSpec) GetMainProcess() *MainProcessSpec { - if x != nil { - return x.MainProcess - } - return nil -} - -// Exact, shell-free specification for the sandbox's canonical main process. -type MainProcessSpec struct { - state protoimpl.MessageState `protogen:"open.v1"` - // Executable followed by its arguments. No shell parsing is performed. - Command []string `protobuf:"bytes,1,rep,name=command,proto3" json:"command,omitempty"` - // Non-secret environment overrides applied only to the main process. - Environment map[string]string `protobuf:"bytes,2,rep,name=environment,proto3" json:"environment,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` - // Optional absolute working directory inside the sandbox. - WorkingDirectory string `protobuf:"bytes,3,opt,name=working_directory,json=workingDirectory,proto3" json:"working_directory,omitempty"` - // Allocate a retained pseudo-terminal for the main process. - Terminal bool `protobuf:"varint,4,opt,name=terminal,proto3" json:"terminal,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *MainProcessSpec) Reset() { - *x = MainProcessSpec{} - mi := &file_openshell_proto_msgTypes[14] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *MainProcessSpec) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*MainProcessSpec) ProtoMessage() {} - -func (x *MainProcessSpec) 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 MainProcessSpec.ProtoReflect.Descriptor instead. -func (*MainProcessSpec) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{14} -} - -func (x *MainProcessSpec) GetCommand() []string { +func (x *SandboxSpec) GetCommand() []string { if x != nil { return x.Command } return nil } -func (x *MainProcessSpec) GetEnvironment() map[string]string { - if x != nil { - return x.Environment - } - return nil -} - -func (x *MainProcessSpec) GetWorkingDirectory() string { +func (x *SandboxSpec) GetTty() bool { if x != nil { - return x.WorkingDirectory - } - return "" -} - -func (x *MainProcessSpec) GetTerminal() bool { - if x != nil { - return x.Terminal + return x.Tty } return false } @@ -1342,7 +1219,7 @@ type ResourceRequirements struct { func (x *ResourceRequirements) Reset() { *x = ResourceRequirements{} - mi := &file_openshell_proto_msgTypes[15] + mi := &file_openshell_proto_msgTypes[14] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1354,7 +1231,7 @@ func (x *ResourceRequirements) String() string { func (*ResourceRequirements) ProtoMessage() {} func (x *ResourceRequirements) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[15] + mi := &file_openshell_proto_msgTypes[14] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1367,7 +1244,7 @@ func (x *ResourceRequirements) ProtoReflect() protoreflect.Message { // Deprecated: Use ResourceRequirements.ProtoReflect.Descriptor instead. func (*ResourceRequirements) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{15} + return file_openshell_proto_rawDescGZIP(), []int{14} } func (x *ResourceRequirements) GetGpu() *GpuResourceRequirements { @@ -1389,7 +1266,7 @@ type GpuResourceRequirements struct { func (x *GpuResourceRequirements) Reset() { *x = GpuResourceRequirements{} - mi := &file_openshell_proto_msgTypes[16] + mi := &file_openshell_proto_msgTypes[15] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1401,7 +1278,7 @@ func (x *GpuResourceRequirements) String() string { func (*GpuResourceRequirements) ProtoMessage() {} func (x *GpuResourceRequirements) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[16] + mi := &file_openshell_proto_msgTypes[15] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1414,7 +1291,7 @@ func (x *GpuResourceRequirements) ProtoReflect() protoreflect.Message { // Deprecated: Use GpuResourceRequirements.ProtoReflect.Descriptor instead. func (*GpuResourceRequirements) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{16} + return file_openshell_proto_rawDescGZIP(), []int{15} } func (x *GpuResourceRequirements) GetCount() uint32 { @@ -1458,7 +1335,7 @@ type SandboxTemplate struct { func (x *SandboxTemplate) Reset() { *x = SandboxTemplate{} - mi := &file_openshell_proto_msgTypes[17] + mi := &file_openshell_proto_msgTypes[16] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1470,7 +1347,7 @@ func (x *SandboxTemplate) String() string { func (*SandboxTemplate) ProtoMessage() {} func (x *SandboxTemplate) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[17] + mi := &file_openshell_proto_msgTypes[16] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1483,7 +1360,7 @@ func (x *SandboxTemplate) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxTemplate.ProtoReflect.Descriptor instead. func (*SandboxTemplate) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{17} + return file_openshell_proto_rawDescGZIP(), []int{16} } func (x *SandboxTemplate) GetImage() string { @@ -1568,15 +1445,19 @@ type SandboxStatus struct { Phase SandboxPhase `protobuf:"varint,6,opt,name=phase,proto3,enum=openshell.v1.SandboxPhase" json:"phase,omitempty"` // Currently active policy version (updated when sandbox reports loaded). CurrentPolicyVersion uint32 `protobuf:"varint,7,opt,name=current_policy_version,json=currentPolicyVersion,proto3" json:"current_policy_version,omitempty"` - // Last observed state of the canonical main process. - MainProcess *MainProcessStatus `protobuf:"bytes,8,opt,name=main_process,json=mainProcess,proto3" json:"main_process,omitempty"` + // Supervisor instance currently associated with the canonical main process. + // The gateway uses this to reject stale exit reports after a restart. + MainProcessInstanceId string `protobuf:"bytes,8,opt,name=main_process_instance_id,json=mainProcessInstanceId,proto3" json:"main_process_instance_id,omitempty"` + // Normalized main process result. Signal exits use 128 + signal number. + // Presence indicates that the main process exited and the sandbox is in Error. + ExitCode *int32 `protobuf:"varint,9,opt,name=exit_code,json=exitCode,proto3,oneof" json:"exit_code,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } func (x *SandboxStatus) Reset() { *x = SandboxStatus{} - mi := &file_openshell_proto_msgTypes[18] + mi := &file_openshell_proto_msgTypes[17] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1588,7 +1469,7 @@ func (x *SandboxStatus) String() string { func (*SandboxStatus) ProtoMessage() {} func (x *SandboxStatus) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[18] + mi := &file_openshell_proto_msgTypes[17] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1601,7 +1482,7 @@ func (x *SandboxStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxStatus.ProtoReflect.Descriptor instead. func (*SandboxStatus) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{18} + return file_openshell_proto_rawDescGZIP(), []int{17} } func (x *SandboxStatus) GetSandboxName() string { @@ -1653,99 +1534,20 @@ func (x *SandboxStatus) GetCurrentPolicyVersion() uint32 { return 0 } -func (x *SandboxStatus) GetMainProcess() *MainProcessStatus { - if x != nil { - return x.MainProcess - } - return nil -} - -// Persisted result for the canonical main-process generation. -type MainProcessStatus struct { - state protoimpl.MessageState `protogen:"open.v1"` - State MainProcessState `protobuf:"varint,1,opt,name=state,proto3,enum=openshell.v1.MainProcessState" json:"state,omitempty"` - // Supervisor instance identifier used to reject stale exit reports. - Generation string `protobuf:"bytes,2,opt,name=generation,proto3" json:"generation,omitempty"` - ExitCode *int32 `protobuf:"varint,3,opt,name=exit_code,json=exitCode,proto3,oneof" json:"exit_code,omitempty"` - Signal *int32 `protobuf:"varint,4,opt,name=signal,proto3,oneof" json:"signal,omitempty"` - StartedAtMs int64 `protobuf:"varint,5,opt,name=started_at_ms,json=startedAtMs,proto3" json:"started_at_ms,omitempty"` - FinishedAtMs int64 `protobuf:"varint,6,opt,name=finished_at_ms,json=finishedAtMs,proto3" json:"finished_at_ms,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *MainProcessStatus) Reset() { - *x = MainProcessStatus{} - mi := &file_openshell_proto_msgTypes[19] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *MainProcessStatus) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*MainProcessStatus) ProtoMessage() {} - -func (x *MainProcessStatus) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[19] +func (x *SandboxStatus) GetMainProcessInstanceId() string { 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 MainProcessStatus.ProtoReflect.Descriptor instead. -func (*MainProcessStatus) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{19} -} - -func (x *MainProcessStatus) GetState() MainProcessState { - if x != nil { - return x.State - } - return MainProcessState_MAIN_PROCESS_STATE_UNSPECIFIED -} - -func (x *MainProcessStatus) GetGeneration() string { - if x != nil { - return x.Generation + return x.MainProcessInstanceId } return "" } -func (x *MainProcessStatus) GetExitCode() int32 { +func (x *SandboxStatus) GetExitCode() int32 { if x != nil && x.ExitCode != nil { return *x.ExitCode } return 0 } -func (x *MainProcessStatus) GetSignal() int32 { - if x != nil && x.Signal != nil { - return *x.Signal - } - return 0 -} - -func (x *MainProcessStatus) GetStartedAtMs() int64 { - if x != nil { - return x.StartedAtMs - } - return 0 -} - -func (x *MainProcessStatus) GetFinishedAtMs() int64 { - if x != nil { - return x.FinishedAtMs - } - return 0 -} - // User-facing sandbox condition derived from driver-native conditions. type SandboxCondition struct { state protoimpl.MessageState `protogen:"open.v1"` @@ -1765,7 +1567,7 @@ type SandboxCondition struct { func (x *SandboxCondition) Reset() { *x = SandboxCondition{} - mi := &file_openshell_proto_msgTypes[20] + mi := &file_openshell_proto_msgTypes[18] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1777,7 +1579,7 @@ func (x *SandboxCondition) String() string { func (*SandboxCondition) ProtoMessage() {} func (x *SandboxCondition) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[20] + mi := &file_openshell_proto_msgTypes[18] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1790,7 +1592,7 @@ func (x *SandboxCondition) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxCondition.ProtoReflect.Descriptor instead. func (*SandboxCondition) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{20} + return file_openshell_proto_rawDescGZIP(), []int{18} } func (x *SandboxCondition) GetType() string { @@ -1849,7 +1651,7 @@ type PlatformEvent struct { func (x *PlatformEvent) Reset() { *x = PlatformEvent{} - mi := &file_openshell_proto_msgTypes[21] + mi := &file_openshell_proto_msgTypes[19] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1861,7 +1663,7 @@ func (x *PlatformEvent) String() string { func (*PlatformEvent) ProtoMessage() {} func (x *PlatformEvent) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[21] + mi := &file_openshell_proto_msgTypes[19] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1874,7 +1676,7 @@ func (x *PlatformEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use PlatformEvent.ProtoReflect.Descriptor instead. func (*PlatformEvent) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{21} + return file_openshell_proto_rawDescGZIP(), []int{19} } func (x *PlatformEvent) GetTimestampMs() int64 { @@ -1937,7 +1739,7 @@ type CreateSandboxRequest struct { func (x *CreateSandboxRequest) Reset() { *x = CreateSandboxRequest{} - mi := &file_openshell_proto_msgTypes[22] + mi := &file_openshell_proto_msgTypes[20] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1949,7 +1751,7 @@ func (x *CreateSandboxRequest) String() string { func (*CreateSandboxRequest) ProtoMessage() {} func (x *CreateSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[22] + mi := &file_openshell_proto_msgTypes[20] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1962,7 +1764,7 @@ func (x *CreateSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateSandboxRequest.ProtoReflect.Descriptor instead. func (*CreateSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{22} + return file_openshell_proto_rawDescGZIP(), []int{20} } func (x *CreateSandboxRequest) GetSpec() *SandboxSpec { @@ -2013,7 +1815,7 @@ type GetSandboxRequest struct { func (x *GetSandboxRequest) Reset() { *x = GetSandboxRequest{} - mi := &file_openshell_proto_msgTypes[23] + mi := &file_openshell_proto_msgTypes[21] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2025,7 +1827,7 @@ func (x *GetSandboxRequest) String() string { func (*GetSandboxRequest) ProtoMessage() {} func (x *GetSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[23] + mi := &file_openshell_proto_msgTypes[21] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2038,7 +1840,7 @@ func (x *GetSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxRequest.ProtoReflect.Descriptor instead. func (*GetSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{23} + return file_openshell_proto_rawDescGZIP(), []int{21} } func (x *GetSandboxRequest) GetName() string { @@ -2072,7 +1874,7 @@ type ListSandboxesRequest struct { func (x *ListSandboxesRequest) Reset() { *x = ListSandboxesRequest{} - mi := &file_openshell_proto_msgTypes[24] + mi := &file_openshell_proto_msgTypes[22] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2084,7 +1886,7 @@ func (x *ListSandboxesRequest) String() string { func (*ListSandboxesRequest) ProtoMessage() {} func (x *ListSandboxesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[24] + mi := &file_openshell_proto_msgTypes[22] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2097,7 +1899,7 @@ func (x *ListSandboxesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxesRequest.ProtoReflect.Descriptor instead. func (*ListSandboxesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{24} + return file_openshell_proto_rawDescGZIP(), []int{22} } func (x *ListSandboxesRequest) GetLimit() uint32 { @@ -2148,7 +1950,7 @@ type ListSandboxProvidersRequest struct { func (x *ListSandboxProvidersRequest) Reset() { *x = ListSandboxProvidersRequest{} - mi := &file_openshell_proto_msgTypes[25] + mi := &file_openshell_proto_msgTypes[23] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2160,7 +1962,7 @@ func (x *ListSandboxProvidersRequest) String() string { func (*ListSandboxProvidersRequest) ProtoMessage() {} func (x *ListSandboxProvidersRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[25] + mi := &file_openshell_proto_msgTypes[23] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2173,7 +1975,7 @@ func (x *ListSandboxProvidersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxProvidersRequest.ProtoReflect.Descriptor instead. func (*ListSandboxProvidersRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{25} + return file_openshell_proto_rawDescGZIP(), []int{23} } func (x *ListSandboxProvidersRequest) GetSandboxName() string { @@ -2210,7 +2012,7 @@ type AttachSandboxProviderRequest struct { func (x *AttachSandboxProviderRequest) Reset() { *x = AttachSandboxProviderRequest{} - mi := &file_openshell_proto_msgTypes[26] + mi := &file_openshell_proto_msgTypes[24] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2222,7 +2024,7 @@ func (x *AttachSandboxProviderRequest) String() string { func (*AttachSandboxProviderRequest) ProtoMessage() {} func (x *AttachSandboxProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[26] + mi := &file_openshell_proto_msgTypes[24] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2235,7 +2037,7 @@ func (x *AttachSandboxProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use AttachSandboxProviderRequest.ProtoReflect.Descriptor instead. func (*AttachSandboxProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{26} + return file_openshell_proto_rawDescGZIP(), []int{24} } func (x *AttachSandboxProviderRequest) GetSandboxName() string { @@ -2286,7 +2088,7 @@ type DetachSandboxProviderRequest struct { func (x *DetachSandboxProviderRequest) Reset() { *x = DetachSandboxProviderRequest{} - mi := &file_openshell_proto_msgTypes[27] + mi := &file_openshell_proto_msgTypes[25] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2298,7 +2100,7 @@ func (x *DetachSandboxProviderRequest) String() string { func (*DetachSandboxProviderRequest) ProtoMessage() {} func (x *DetachSandboxProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[27] + mi := &file_openshell_proto_msgTypes[25] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2311,7 +2113,7 @@ func (x *DetachSandboxProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DetachSandboxProviderRequest.ProtoReflect.Descriptor instead. func (*DetachSandboxProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{27} + return file_openshell_proto_rawDescGZIP(), []int{25} } func (x *DetachSandboxProviderRequest) GetSandboxName() string { @@ -2355,7 +2157,7 @@ type DeleteSandboxRequest struct { func (x *DeleteSandboxRequest) Reset() { *x = DeleteSandboxRequest{} - mi := &file_openshell_proto_msgTypes[28] + mi := &file_openshell_proto_msgTypes[26] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2367,7 +2169,7 @@ func (x *DeleteSandboxRequest) String() string { func (*DeleteSandboxRequest) ProtoMessage() {} func (x *DeleteSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[28] + mi := &file_openshell_proto_msgTypes[26] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2380,7 +2182,7 @@ func (x *DeleteSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteSandboxRequest.ProtoReflect.Descriptor instead. func (*DeleteSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{28} + return file_openshell_proto_rawDescGZIP(), []int{26} } func (x *DeleteSandboxRequest) GetName() string { @@ -2410,7 +2212,7 @@ type StopSandboxRequest struct { func (x *StopSandboxRequest) Reset() { *x = StopSandboxRequest{} - mi := &file_openshell_proto_msgTypes[29] + mi := &file_openshell_proto_msgTypes[27] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2422,7 +2224,7 @@ func (x *StopSandboxRequest) String() string { func (*StopSandboxRequest) ProtoMessage() {} func (x *StopSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[29] + mi := &file_openshell_proto_msgTypes[27] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2435,7 +2237,7 @@ func (x *StopSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use StopSandboxRequest.ProtoReflect.Descriptor instead. func (*StopSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{29} + return file_openshell_proto_rawDescGZIP(), []int{27} } func (x *StopSandboxRequest) GetName() string { @@ -2465,7 +2267,7 @@ type StartSandboxRequest struct { func (x *StartSandboxRequest) Reset() { *x = StartSandboxRequest{} - mi := &file_openshell_proto_msgTypes[30] + mi := &file_openshell_proto_msgTypes[28] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2477,7 +2279,7 @@ func (x *StartSandboxRequest) String() string { func (*StartSandboxRequest) ProtoMessage() {} func (x *StartSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[30] + mi := &file_openshell_proto_msgTypes[28] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2490,7 +2292,7 @@ func (x *StartSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use StartSandboxRequest.ProtoReflect.Descriptor instead. func (*StartSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{30} + return file_openshell_proto_rawDescGZIP(), []int{28} } func (x *StartSandboxRequest) GetName() string { @@ -2517,7 +2319,7 @@ type SandboxResponse struct { func (x *SandboxResponse) Reset() { *x = SandboxResponse{} - mi := &file_openshell_proto_msgTypes[31] + mi := &file_openshell_proto_msgTypes[29] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2529,7 +2331,7 @@ func (x *SandboxResponse) String() string { func (*SandboxResponse) ProtoMessage() {} func (x *SandboxResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[31] + mi := &file_openshell_proto_msgTypes[29] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2542,7 +2344,7 @@ func (x *SandboxResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxResponse.ProtoReflect.Descriptor instead. func (*SandboxResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{31} + return file_openshell_proto_rawDescGZIP(), []int{29} } func (x *SandboxResponse) GetSandbox() *Sandbox { @@ -2562,7 +2364,7 @@ type ListSandboxesResponse struct { func (x *ListSandboxesResponse) Reset() { *x = ListSandboxesResponse{} - mi := &file_openshell_proto_msgTypes[32] + mi := &file_openshell_proto_msgTypes[30] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2574,7 +2376,7 @@ func (x *ListSandboxesResponse) String() string { func (*ListSandboxesResponse) ProtoMessage() {} func (x *ListSandboxesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[32] + mi := &file_openshell_proto_msgTypes[30] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2587,7 +2389,7 @@ func (x *ListSandboxesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxesResponse.ProtoReflect.Descriptor instead. func (*ListSandboxesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{32} + return file_openshell_proto_rawDescGZIP(), []int{30} } func (x *ListSandboxesResponse) GetSandboxes() []*Sandbox { @@ -2607,7 +2409,7 @@ type ListSandboxProvidersResponse struct { func (x *ListSandboxProvidersResponse) Reset() { *x = ListSandboxProvidersResponse{} - mi := &file_openshell_proto_msgTypes[33] + mi := &file_openshell_proto_msgTypes[31] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2619,7 +2421,7 @@ func (x *ListSandboxProvidersResponse) String() string { func (*ListSandboxProvidersResponse) ProtoMessage() {} func (x *ListSandboxProvidersResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[33] + mi := &file_openshell_proto_msgTypes[31] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2632,7 +2434,7 @@ func (x *ListSandboxProvidersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxProvidersResponse.ProtoReflect.Descriptor instead. func (*ListSandboxProvidersResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{33} + return file_openshell_proto_rawDescGZIP(), []int{31} } func (x *ListSandboxProvidersResponse) GetProviders() []*datamodelv1.Provider { @@ -2654,7 +2456,7 @@ type AttachSandboxProviderResponse struct { func (x *AttachSandboxProviderResponse) Reset() { *x = AttachSandboxProviderResponse{} - mi := &file_openshell_proto_msgTypes[34] + mi := &file_openshell_proto_msgTypes[32] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2666,7 +2468,7 @@ func (x *AttachSandboxProviderResponse) String() string { func (*AttachSandboxProviderResponse) ProtoMessage() {} func (x *AttachSandboxProviderResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[34] + mi := &file_openshell_proto_msgTypes[32] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2679,7 +2481,7 @@ func (x *AttachSandboxProviderResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use AttachSandboxProviderResponse.ProtoReflect.Descriptor instead. func (*AttachSandboxProviderResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{34} + return file_openshell_proto_rawDescGZIP(), []int{32} } func (x *AttachSandboxProviderResponse) GetSandbox() *Sandbox { @@ -2708,7 +2510,7 @@ type DetachSandboxProviderResponse struct { func (x *DetachSandboxProviderResponse) Reset() { *x = DetachSandboxProviderResponse{} - mi := &file_openshell_proto_msgTypes[35] + mi := &file_openshell_proto_msgTypes[33] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2720,7 +2522,7 @@ func (x *DetachSandboxProviderResponse) String() string { func (*DetachSandboxProviderResponse) ProtoMessage() {} func (x *DetachSandboxProviderResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[35] + mi := &file_openshell_proto_msgTypes[33] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2733,7 +2535,7 @@ func (x *DetachSandboxProviderResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DetachSandboxProviderResponse.ProtoReflect.Descriptor instead. func (*DetachSandboxProviderResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{35} + return file_openshell_proto_rawDescGZIP(), []int{33} } func (x *DetachSandboxProviderResponse) GetSandbox() *Sandbox { @@ -2760,7 +2562,7 @@ type DeleteSandboxResponse struct { func (x *DeleteSandboxResponse) Reset() { *x = DeleteSandboxResponse{} - mi := &file_openshell_proto_msgTypes[36] + mi := &file_openshell_proto_msgTypes[34] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2772,7 +2574,7 @@ func (x *DeleteSandboxResponse) String() string { func (*DeleteSandboxResponse) ProtoMessage() {} func (x *DeleteSandboxResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[36] + mi := &file_openshell_proto_msgTypes[34] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2785,7 +2587,7 @@ func (x *DeleteSandboxResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteSandboxResponse.ProtoReflect.Descriptor instead. func (*DeleteSandboxResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{36} + return file_openshell_proto_rawDescGZIP(), []int{34} } func (x *DeleteSandboxResponse) GetDeleted() bool { @@ -2806,7 +2608,7 @@ type CreateSshSessionRequest struct { func (x *CreateSshSessionRequest) Reset() { *x = CreateSshSessionRequest{} - mi := &file_openshell_proto_msgTypes[37] + mi := &file_openshell_proto_msgTypes[35] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2818,7 +2620,7 @@ func (x *CreateSshSessionRequest) String() string { func (*CreateSshSessionRequest) ProtoMessage() {} func (x *CreateSshSessionRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[37] + mi := &file_openshell_proto_msgTypes[35] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2831,7 +2633,7 @@ func (x *CreateSshSessionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateSshSessionRequest.ProtoReflect.Descriptor instead. func (*CreateSshSessionRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{37} + return file_openshell_proto_rawDescGZIP(), []int{35} } func (x *CreateSshSessionRequest) GetSandboxId() string { @@ -2874,7 +2676,7 @@ type CreateSshSessionResponse struct { func (x *CreateSshSessionResponse) Reset() { *x = CreateSshSessionResponse{} - mi := &file_openshell_proto_msgTypes[38] + mi := &file_openshell_proto_msgTypes[36] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2886,7 +2688,7 @@ func (x *CreateSshSessionResponse) String() string { func (*CreateSshSessionResponse) ProtoMessage() {} func (x *CreateSshSessionResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[38] + mi := &file_openshell_proto_msgTypes[36] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2899,7 +2701,7 @@ func (x *CreateSshSessionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateSshSessionResponse.ProtoReflect.Descriptor instead. func (*CreateSshSessionResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{38} + return file_openshell_proto_rawDescGZIP(), []int{36} } func (x *CreateSshSessionResponse) GetSandboxId() string { @@ -2970,7 +2772,7 @@ type ExposeServiceRequest struct { func (x *ExposeServiceRequest) Reset() { *x = ExposeServiceRequest{} - mi := &file_openshell_proto_msgTypes[39] + mi := &file_openshell_proto_msgTypes[37] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2982,7 +2784,7 @@ func (x *ExposeServiceRequest) String() string { func (*ExposeServiceRequest) ProtoMessage() {} func (x *ExposeServiceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[39] + mi := &file_openshell_proto_msgTypes[37] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2995,7 +2797,7 @@ func (x *ExposeServiceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ExposeServiceRequest.ProtoReflect.Descriptor instead. func (*ExposeServiceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{39} + return file_openshell_proto_rawDescGZIP(), []int{37} } func (x *ExposeServiceRequest) GetSandbox() string { @@ -3048,7 +2850,7 @@ type GetServiceRequest struct { func (x *GetServiceRequest) Reset() { *x = GetServiceRequest{} - mi := &file_openshell_proto_msgTypes[40] + mi := &file_openshell_proto_msgTypes[38] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3060,7 +2862,7 @@ func (x *GetServiceRequest) String() string { func (*GetServiceRequest) ProtoMessage() {} func (x *GetServiceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[40] + mi := &file_openshell_proto_msgTypes[38] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3073,7 +2875,7 @@ func (x *GetServiceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetServiceRequest.ProtoReflect.Descriptor instead. func (*GetServiceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{40} + return file_openshell_proto_rawDescGZIP(), []int{38} } func (x *GetServiceRequest) GetSandbox() string { @@ -3116,7 +2918,7 @@ type ListServicesRequest struct { func (x *ListServicesRequest) Reset() { *x = ListServicesRequest{} - mi := &file_openshell_proto_msgTypes[41] + mi := &file_openshell_proto_msgTypes[39] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3128,7 +2930,7 @@ func (x *ListServicesRequest) String() string { func (*ListServicesRequest) ProtoMessage() {} func (x *ListServicesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[41] + mi := &file_openshell_proto_msgTypes[39] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3141,7 +2943,7 @@ func (x *ListServicesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListServicesRequest.ProtoReflect.Descriptor instead. func (*ListServicesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{41} + return file_openshell_proto_rawDescGZIP(), []int{39} } func (x *ListServicesRequest) GetSandbox() string { @@ -3189,7 +2991,7 @@ type ListServicesResponse struct { func (x *ListServicesResponse) Reset() { *x = ListServicesResponse{} - mi := &file_openshell_proto_msgTypes[42] + mi := &file_openshell_proto_msgTypes[40] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3201,7 +3003,7 @@ func (x *ListServicesResponse) String() string { func (*ListServicesResponse) ProtoMessage() {} func (x *ListServicesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[42] + mi := &file_openshell_proto_msgTypes[40] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3214,7 +3016,7 @@ func (x *ListServicesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListServicesResponse.ProtoReflect.Descriptor instead. func (*ListServicesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{42} + return file_openshell_proto_rawDescGZIP(), []int{40} } func (x *ListServicesResponse) GetServices() []*ServiceEndpointResponse { @@ -3239,7 +3041,7 @@ type DeleteServiceRequest struct { func (x *DeleteServiceRequest) Reset() { *x = DeleteServiceRequest{} - mi := &file_openshell_proto_msgTypes[43] + mi := &file_openshell_proto_msgTypes[41] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3251,7 +3053,7 @@ func (x *DeleteServiceRequest) String() string { func (*DeleteServiceRequest) ProtoMessage() {} func (x *DeleteServiceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[43] + mi := &file_openshell_proto_msgTypes[41] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3264,7 +3066,7 @@ func (x *DeleteServiceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteServiceRequest.ProtoReflect.Descriptor instead. func (*DeleteServiceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{43} + return file_openshell_proto_rawDescGZIP(), []int{41} } func (x *DeleteServiceRequest) GetSandbox() string { @@ -3299,7 +3101,7 @@ type DeleteServiceResponse struct { func (x *DeleteServiceResponse) Reset() { *x = DeleteServiceResponse{} - mi := &file_openshell_proto_msgTypes[44] + mi := &file_openshell_proto_msgTypes[42] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3311,7 +3113,7 @@ func (x *DeleteServiceResponse) String() string { func (*DeleteServiceResponse) ProtoMessage() {} func (x *DeleteServiceResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[44] + mi := &file_openshell_proto_msgTypes[42] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3324,7 +3126,7 @@ func (x *DeleteServiceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteServiceResponse.ProtoReflect.Descriptor instead. func (*DeleteServiceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{44} + return file_openshell_proto_rawDescGZIP(), []int{42} } func (x *DeleteServiceResponse) GetDeleted() bool { @@ -3355,7 +3157,7 @@ type ServiceEndpoint struct { func (x *ServiceEndpoint) Reset() { *x = ServiceEndpoint{} - mi := &file_openshell_proto_msgTypes[45] + mi := &file_openshell_proto_msgTypes[43] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3367,7 +3169,7 @@ func (x *ServiceEndpoint) String() string { func (*ServiceEndpoint) ProtoMessage() {} func (x *ServiceEndpoint) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[45] + mi := &file_openshell_proto_msgTypes[43] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3380,7 +3182,7 @@ func (x *ServiceEndpoint) ProtoReflect() protoreflect.Message { // Deprecated: Use ServiceEndpoint.ProtoReflect.Descriptor instead. func (*ServiceEndpoint) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{45} + return file_openshell_proto_rawDescGZIP(), []int{43} } func (x *ServiceEndpoint) GetMetadata() *datamodelv1.ObjectMeta { @@ -3436,7 +3238,7 @@ type ServiceEndpointResponse struct { func (x *ServiceEndpointResponse) Reset() { *x = ServiceEndpointResponse{} - mi := &file_openshell_proto_msgTypes[46] + mi := &file_openshell_proto_msgTypes[44] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3448,7 +3250,7 @@ func (x *ServiceEndpointResponse) String() string { func (*ServiceEndpointResponse) ProtoMessage() {} func (x *ServiceEndpointResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[46] + mi := &file_openshell_proto_msgTypes[44] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3461,7 +3263,7 @@ func (x *ServiceEndpointResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ServiceEndpointResponse.ProtoReflect.Descriptor instead. func (*ServiceEndpointResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{46} + return file_openshell_proto_rawDescGZIP(), []int{44} } func (x *ServiceEndpointResponse) GetEndpoint() *ServiceEndpoint { @@ -3489,7 +3291,7 @@ type RevokeSshSessionRequest struct { func (x *RevokeSshSessionRequest) Reset() { *x = RevokeSshSessionRequest{} - mi := &file_openshell_proto_msgTypes[47] + mi := &file_openshell_proto_msgTypes[45] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3501,7 +3303,7 @@ func (x *RevokeSshSessionRequest) String() string { func (*RevokeSshSessionRequest) ProtoMessage() {} func (x *RevokeSshSessionRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[47] + mi := &file_openshell_proto_msgTypes[45] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3514,7 +3316,7 @@ func (x *RevokeSshSessionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RevokeSshSessionRequest.ProtoReflect.Descriptor instead. func (*RevokeSshSessionRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{47} + return file_openshell_proto_rawDescGZIP(), []int{45} } func (x *RevokeSshSessionRequest) GetToken() string { @@ -3535,7 +3337,7 @@ type RevokeSshSessionResponse struct { func (x *RevokeSshSessionResponse) Reset() { *x = RevokeSshSessionResponse{} - mi := &file_openshell_proto_msgTypes[48] + mi := &file_openshell_proto_msgTypes[46] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3547,7 +3349,7 @@ func (x *RevokeSshSessionResponse) String() string { func (*RevokeSshSessionResponse) ProtoMessage() {} func (x *RevokeSshSessionResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[48] + mi := &file_openshell_proto_msgTypes[46] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3560,7 +3362,7 @@ func (x *RevokeSshSessionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RevokeSshSessionResponse.ProtoReflect.Descriptor instead. func (*RevokeSshSessionResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{48} + return file_openshell_proto_rawDescGZIP(), []int{46} } func (x *RevokeSshSessionResponse) GetRevoked() bool { @@ -3597,7 +3399,7 @@ type ExecSandboxRequest struct { func (x *ExecSandboxRequest) Reset() { *x = ExecSandboxRequest{} - mi := &file_openshell_proto_msgTypes[49] + mi := &file_openshell_proto_msgTypes[47] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3609,7 +3411,7 @@ func (x *ExecSandboxRequest) String() string { func (*ExecSandboxRequest) ProtoMessage() {} func (x *ExecSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[49] + mi := &file_openshell_proto_msgTypes[47] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3622,7 +3424,7 @@ func (x *ExecSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxRequest.ProtoReflect.Descriptor instead. func (*ExecSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{49} + return file_openshell_proto_rawDescGZIP(), []int{47} } func (x *ExecSandboxRequest) GetSandboxId() string { @@ -3698,7 +3500,7 @@ type ExecSandboxStdout struct { func (x *ExecSandboxStdout) Reset() { *x = ExecSandboxStdout{} - mi := &file_openshell_proto_msgTypes[50] + mi := &file_openshell_proto_msgTypes[48] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3710,7 +3512,7 @@ func (x *ExecSandboxStdout) String() string { func (*ExecSandboxStdout) ProtoMessage() {} func (x *ExecSandboxStdout) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[50] + mi := &file_openshell_proto_msgTypes[48] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3723,7 +3525,7 @@ func (x *ExecSandboxStdout) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxStdout.ProtoReflect.Descriptor instead. func (*ExecSandboxStdout) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{50} + return file_openshell_proto_rawDescGZIP(), []int{48} } func (x *ExecSandboxStdout) GetData() []byte { @@ -3743,7 +3545,7 @@ type ExecSandboxStderr struct { func (x *ExecSandboxStderr) Reset() { *x = ExecSandboxStderr{} - mi := &file_openshell_proto_msgTypes[51] + mi := &file_openshell_proto_msgTypes[49] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3755,7 +3557,7 @@ func (x *ExecSandboxStderr) String() string { func (*ExecSandboxStderr) ProtoMessage() {} func (x *ExecSandboxStderr) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[51] + mi := &file_openshell_proto_msgTypes[49] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3768,7 +3570,7 @@ func (x *ExecSandboxStderr) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxStderr.ProtoReflect.Descriptor instead. func (*ExecSandboxStderr) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{51} + return file_openshell_proto_rawDescGZIP(), []int{49} } func (x *ExecSandboxStderr) GetData() []byte { @@ -3788,7 +3590,7 @@ type ExecSandboxExit struct { func (x *ExecSandboxExit) Reset() { *x = ExecSandboxExit{} - mi := &file_openshell_proto_msgTypes[52] + mi := &file_openshell_proto_msgTypes[50] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3800,7 +3602,7 @@ func (x *ExecSandboxExit) String() string { func (*ExecSandboxExit) ProtoMessage() {} func (x *ExecSandboxExit) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[52] + mi := &file_openshell_proto_msgTypes[50] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3813,7 +3615,7 @@ func (x *ExecSandboxExit) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxExit.ProtoReflect.Descriptor instead. func (*ExecSandboxExit) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{52} + return file_openshell_proto_rawDescGZIP(), []int{50} } func (x *ExecSandboxExit) GetExitCode() int32 { @@ -3838,7 +3640,7 @@ type ExecSandboxEvent struct { func (x *ExecSandboxEvent) Reset() { *x = ExecSandboxEvent{} - mi := &file_openshell_proto_msgTypes[53] + mi := &file_openshell_proto_msgTypes[51] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3850,7 +3652,7 @@ func (x *ExecSandboxEvent) String() string { func (*ExecSandboxEvent) ProtoMessage() {} func (x *ExecSandboxEvent) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[53] + mi := &file_openshell_proto_msgTypes[51] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3863,7 +3665,7 @@ func (x *ExecSandboxEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxEvent.ProtoReflect.Descriptor instead. func (*ExecSandboxEvent) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{53} + return file_openshell_proto_rawDescGZIP(), []int{51} } func (x *ExecSandboxEvent) GetPayload() isExecSandboxEvent_Payload { @@ -3945,7 +3747,7 @@ type TcpForwardInit struct { func (x *TcpForwardInit) Reset() { *x = TcpForwardInit{} - mi := &file_openshell_proto_msgTypes[54] + mi := &file_openshell_proto_msgTypes[52] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3957,7 +3759,7 @@ func (x *TcpForwardInit) String() string { func (*TcpForwardInit) ProtoMessage() {} func (x *TcpForwardInit) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[54] + mi := &file_openshell_proto_msgTypes[52] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3970,7 +3772,7 @@ func (x *TcpForwardInit) ProtoReflect() protoreflect.Message { // Deprecated: Use TcpForwardInit.ProtoReflect.Descriptor instead. func (*TcpForwardInit) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{54} + return file_openshell_proto_rawDescGZIP(), []int{52} } func (x *TcpForwardInit) GetSandboxId() string { @@ -4049,7 +3851,7 @@ type TcpForwardFrame struct { func (x *TcpForwardFrame) Reset() { *x = TcpForwardFrame{} - mi := &file_openshell_proto_msgTypes[55] + mi := &file_openshell_proto_msgTypes[53] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4061,7 +3863,7 @@ func (x *TcpForwardFrame) String() string { func (*TcpForwardFrame) ProtoMessage() {} func (x *TcpForwardFrame) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[55] + mi := &file_openshell_proto_msgTypes[53] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4074,7 +3876,7 @@ func (x *TcpForwardFrame) ProtoReflect() protoreflect.Message { // Deprecated: Use TcpForwardFrame.ProtoReflect.Descriptor instead. func (*TcpForwardFrame) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{55} + return file_openshell_proto_rawDescGZIP(), []int{53} } func (x *TcpForwardFrame) GetPayload() isTcpForwardFrame_Payload { @@ -4133,7 +3935,7 @@ type ExecSandboxInput struct { func (x *ExecSandboxInput) Reset() { *x = ExecSandboxInput{} - mi := &file_openshell_proto_msgTypes[56] + mi := &file_openshell_proto_msgTypes[54] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4145,7 +3947,7 @@ func (x *ExecSandboxInput) String() string { func (*ExecSandboxInput) ProtoMessage() {} func (x *ExecSandboxInput) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[56] + mi := &file_openshell_proto_msgTypes[54] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4158,7 +3960,7 @@ func (x *ExecSandboxInput) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxInput.ProtoReflect.Descriptor instead. func (*ExecSandboxInput) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{56} + return file_openshell_proto_rawDescGZIP(), []int{54} } func (x *ExecSandboxInput) GetPayload() isExecSandboxInput_Payload { @@ -4231,7 +4033,7 @@ type ExecSandboxWindowResize struct { func (x *ExecSandboxWindowResize) Reset() { *x = ExecSandboxWindowResize{} - mi := &file_openshell_proto_msgTypes[57] + mi := &file_openshell_proto_msgTypes[55] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4243,7 +4045,7 @@ func (x *ExecSandboxWindowResize) String() string { func (*ExecSandboxWindowResize) ProtoMessage() {} func (x *ExecSandboxWindowResize) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[57] + mi := &file_openshell_proto_msgTypes[55] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4256,7 +4058,7 @@ func (x *ExecSandboxWindowResize) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecSandboxWindowResize.ProtoReflect.Descriptor instead. func (*ExecSandboxWindowResize) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{57} + return file_openshell_proto_rawDescGZIP(), []int{55} } func (x *ExecSandboxWindowResize) GetCols() uint32 { @@ -4293,7 +4095,7 @@ type SshSession struct { func (x *SshSession) Reset() { *x = SshSession{} - mi := &file_openshell_proto_msgTypes[58] + mi := &file_openshell_proto_msgTypes[56] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4305,7 +4107,7 @@ func (x *SshSession) String() string { func (*SshSession) ProtoMessage() {} func (x *SshSession) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[58] + mi := &file_openshell_proto_msgTypes[56] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4318,7 +4120,7 @@ func (x *SshSession) ProtoReflect() protoreflect.Message { // Deprecated: Use SshSession.ProtoReflect.Descriptor instead. func (*SshSession) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{58} + return file_openshell_proto_rawDescGZIP(), []int{56} } func (x *SshSession) GetMetadata() *datamodelv1.ObjectMeta { @@ -4386,7 +4188,7 @@ type WatchSandboxRequest struct { func (x *WatchSandboxRequest) Reset() { *x = WatchSandboxRequest{} - mi := &file_openshell_proto_msgTypes[59] + mi := &file_openshell_proto_msgTypes[57] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4398,7 +4200,7 @@ func (x *WatchSandboxRequest) String() string { func (*WatchSandboxRequest) ProtoMessage() {} func (x *WatchSandboxRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[59] + mi := &file_openshell_proto_msgTypes[57] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4411,7 +4213,7 @@ func (x *WatchSandboxRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use WatchSandboxRequest.ProtoReflect.Descriptor instead. func (*WatchSandboxRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{59} + return file_openshell_proto_rawDescGZIP(), []int{57} } func (x *WatchSandboxRequest) GetId() string { @@ -4501,7 +4303,7 @@ type SandboxStreamEvent struct { func (x *SandboxStreamEvent) Reset() { *x = SandboxStreamEvent{} - mi := &file_openshell_proto_msgTypes[60] + mi := &file_openshell_proto_msgTypes[58] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4513,7 +4315,7 @@ func (x *SandboxStreamEvent) String() string { func (*SandboxStreamEvent) ProtoMessage() {} func (x *SandboxStreamEvent) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[60] + mi := &file_openshell_proto_msgTypes[58] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4526,7 +4328,7 @@ func (x *SandboxStreamEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxStreamEvent.ProtoReflect.Descriptor instead. func (*SandboxStreamEvent) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{60} + return file_openshell_proto_rawDescGZIP(), []int{58} } func (x *SandboxStreamEvent) GetPayload() isSandboxStreamEvent_Payload { @@ -4639,7 +4441,7 @@ type SandboxLogLine struct { func (x *SandboxLogLine) Reset() { *x = SandboxLogLine{} - mi := &file_openshell_proto_msgTypes[61] + mi := &file_openshell_proto_msgTypes[59] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4651,7 +4453,7 @@ func (x *SandboxLogLine) String() string { func (*SandboxLogLine) ProtoMessage() {} func (x *SandboxLogLine) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[61] + mi := &file_openshell_proto_msgTypes[59] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4664,7 +4466,7 @@ func (x *SandboxLogLine) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxLogLine.ProtoReflect.Descriptor instead. func (*SandboxLogLine) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{61} + return file_openshell_proto_rawDescGZIP(), []int{59} } func (x *SandboxLogLine) GetSandboxId() string { @@ -4725,7 +4527,7 @@ type SandboxStreamWarning struct { func (x *SandboxStreamWarning) Reset() { *x = SandboxStreamWarning{} - mi := &file_openshell_proto_msgTypes[62] + mi := &file_openshell_proto_msgTypes[60] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4737,7 +4539,7 @@ func (x *SandboxStreamWarning) String() string { func (*SandboxStreamWarning) ProtoMessage() {} func (x *SandboxStreamWarning) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[62] + mi := &file_openshell_proto_msgTypes[60] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4750,7 +4552,7 @@ func (x *SandboxStreamWarning) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxStreamWarning.ProtoReflect.Descriptor instead. func (*SandboxStreamWarning) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{62} + return file_openshell_proto_rawDescGZIP(), []int{60} } func (x *SandboxStreamWarning) GetMessage() string { @@ -4772,7 +4574,7 @@ type CreateProviderRequest struct { func (x *CreateProviderRequest) Reset() { *x = CreateProviderRequest{} - mi := &file_openshell_proto_msgTypes[63] + mi := &file_openshell_proto_msgTypes[61] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4784,7 +4586,7 @@ func (x *CreateProviderRequest) String() string { func (*CreateProviderRequest) ProtoMessage() {} func (x *CreateProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[63] + mi := &file_openshell_proto_msgTypes[61] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4797,7 +4599,7 @@ func (x *CreateProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateProviderRequest.ProtoReflect.Descriptor instead. func (*CreateProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{63} + return file_openshell_proto_rawDescGZIP(), []int{61} } func (x *CreateProviderRequest) GetProvider() *datamodelv1.Provider { @@ -4826,7 +4628,7 @@ type GetProviderRequest struct { func (x *GetProviderRequest) Reset() { *x = GetProviderRequest{} - mi := &file_openshell_proto_msgTypes[64] + mi := &file_openshell_proto_msgTypes[62] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4838,7 +4640,7 @@ func (x *GetProviderRequest) String() string { func (*GetProviderRequest) ProtoMessage() {} func (x *GetProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[64] + mi := &file_openshell_proto_msgTypes[62] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4851,7 +4653,7 @@ func (x *GetProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderRequest.ProtoReflect.Descriptor instead. func (*GetProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{64} + return file_openshell_proto_rawDescGZIP(), []int{62} } func (x *GetProviderRequest) GetName() string { @@ -4883,7 +4685,7 @@ type ListProvidersRequest struct { func (x *ListProvidersRequest) Reset() { *x = ListProvidersRequest{} - mi := &file_openshell_proto_msgTypes[65] + mi := &file_openshell_proto_msgTypes[63] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4895,7 +4697,7 @@ func (x *ListProvidersRequest) String() string { func (*ListProvidersRequest) ProtoMessage() {} func (x *ListProvidersRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[65] + mi := &file_openshell_proto_msgTypes[63] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4908,7 +4710,7 @@ func (x *ListProvidersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProvidersRequest.ProtoReflect.Descriptor instead. func (*ListProvidersRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{65} + return file_openshell_proto_rawDescGZIP(), []int{63} } func (x *ListProvidersRequest) GetLimit() uint32 { @@ -4954,7 +4756,7 @@ type UpdateProviderRequest struct { func (x *UpdateProviderRequest) Reset() { *x = UpdateProviderRequest{} - mi := &file_openshell_proto_msgTypes[66] + mi := &file_openshell_proto_msgTypes[64] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4966,7 +4768,7 @@ func (x *UpdateProviderRequest) String() string { func (*UpdateProviderRequest) ProtoMessage() {} func (x *UpdateProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[66] + mi := &file_openshell_proto_msgTypes[64] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4979,7 +4781,7 @@ func (x *UpdateProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateProviderRequest.ProtoReflect.Descriptor instead. func (*UpdateProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{66} + return file_openshell_proto_rawDescGZIP(), []int{64} } func (x *UpdateProviderRequest) GetProvider() *datamodelv1.Provider { @@ -5015,7 +4817,7 @@ type DeleteProviderRequest struct { func (x *DeleteProviderRequest) Reset() { *x = DeleteProviderRequest{} - mi := &file_openshell_proto_msgTypes[67] + mi := &file_openshell_proto_msgTypes[65] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5027,7 +4829,7 @@ func (x *DeleteProviderRequest) String() string { func (*DeleteProviderRequest) ProtoMessage() {} func (x *DeleteProviderRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[67] + mi := &file_openshell_proto_msgTypes[65] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5040,7 +4842,7 @@ func (x *DeleteProviderRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteProviderRequest.ProtoReflect.Descriptor instead. func (*DeleteProviderRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{67} + return file_openshell_proto_rawDescGZIP(), []int{65} } func (x *DeleteProviderRequest) GetName() string { @@ -5067,7 +4869,7 @@ type ProviderResponse struct { func (x *ProviderResponse) Reset() { *x = ProviderResponse{} - mi := &file_openshell_proto_msgTypes[68] + mi := &file_openshell_proto_msgTypes[66] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5079,7 +4881,7 @@ func (x *ProviderResponse) String() string { func (*ProviderResponse) ProtoMessage() {} func (x *ProviderResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[68] + mi := &file_openshell_proto_msgTypes[66] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5092,7 +4894,7 @@ func (x *ProviderResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderResponse.ProtoReflect.Descriptor instead. func (*ProviderResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{68} + return file_openshell_proto_rawDescGZIP(), []int{66} } func (x *ProviderResponse) GetProvider() *datamodelv1.Provider { @@ -5112,7 +4914,7 @@ type ListProvidersResponse struct { func (x *ListProvidersResponse) Reset() { *x = ListProvidersResponse{} - mi := &file_openshell_proto_msgTypes[69] + mi := &file_openshell_proto_msgTypes[67] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5124,7 +4926,7 @@ func (x *ListProvidersResponse) String() string { func (*ListProvidersResponse) ProtoMessage() {} func (x *ListProvidersResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[69] + mi := &file_openshell_proto_msgTypes[67] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5137,7 +4939,7 @@ func (x *ListProvidersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProvidersResponse.ProtoReflect.Descriptor instead. func (*ListProvidersResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{69} + return file_openshell_proto_rawDescGZIP(), []int{67} } func (x *ListProvidersResponse) GetProviders() []*datamodelv1.Provider { @@ -5161,7 +4963,7 @@ type ListProviderProfilesRequest struct { func (x *ListProviderProfilesRequest) Reset() { *x = ListProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[70] + mi := &file_openshell_proto_msgTypes[68] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5173,7 +4975,7 @@ func (x *ListProviderProfilesRequest) String() string { func (*ListProviderProfilesRequest) ProtoMessage() {} func (x *ListProviderProfilesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[70] + mi := &file_openshell_proto_msgTypes[68] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5186,7 +4988,7 @@ func (x *ListProviderProfilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListProviderProfilesRequest.ProtoReflect.Descriptor instead. func (*ListProviderProfilesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{70} + return file_openshell_proto_rawDescGZIP(), []int{68} } func (x *ListProviderProfilesRequest) GetLimit() uint32 { @@ -5224,7 +5026,7 @@ type GetProviderProfileRequest struct { func (x *GetProviderProfileRequest) Reset() { *x = GetProviderProfileRequest{} - mi := &file_openshell_proto_msgTypes[71] + mi := &file_openshell_proto_msgTypes[69] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5236,7 +5038,7 @@ func (x *GetProviderProfileRequest) String() string { func (*GetProviderProfileRequest) ProtoMessage() {} func (x *GetProviderProfileRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[71] + mi := &file_openshell_proto_msgTypes[69] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5249,7 +5051,7 @@ func (x *GetProviderProfileRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetProviderProfileRequest.ProtoReflect.Descriptor instead. func (*GetProviderProfileRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{71} + return file_openshell_proto_rawDescGZIP(), []int{69} } func (x *GetProviderProfileRequest) GetId() string { @@ -5277,7 +5079,7 @@ type ProviderProfileImportItem struct { func (x *ProviderProfileImportItem) Reset() { *x = ProviderProfileImportItem{} - mi := &file_openshell_proto_msgTypes[72] + mi := &file_openshell_proto_msgTypes[70] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5289,7 +5091,7 @@ func (x *ProviderProfileImportItem) String() string { func (*ProviderProfileImportItem) ProtoMessage() {} func (x *ProviderProfileImportItem) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[72] + mi := &file_openshell_proto_msgTypes[70] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5302,7 +5104,7 @@ func (x *ProviderProfileImportItem) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileImportItem.ProtoReflect.Descriptor instead. func (*ProviderProfileImportItem) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{72} + return file_openshell_proto_rawDescGZIP(), []int{70} } func (x *ProviderProfileImportItem) GetProfile() *ProviderProfile { @@ -5333,7 +5135,7 @@ type ProviderProfileDiagnostic struct { func (x *ProviderProfileDiagnostic) Reset() { *x = ProviderProfileDiagnostic{} - mi := &file_openshell_proto_msgTypes[73] + mi := &file_openshell_proto_msgTypes[71] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5345,7 +5147,7 @@ func (x *ProviderProfileDiagnostic) String() string { func (*ProviderProfileDiagnostic) ProtoMessage() {} func (x *ProviderProfileDiagnostic) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[73] + mi := &file_openshell_proto_msgTypes[71] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5358,7 +5160,7 @@ func (x *ProviderProfileDiagnostic) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileDiagnostic.ProtoReflect.Descriptor instead. func (*ProviderProfileDiagnostic) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{73} + return file_openshell_proto_rawDescGZIP(), []int{71} } func (x *ProviderProfileDiagnostic) GetSource() string { @@ -5415,7 +5217,7 @@ type ProviderCredentialTokenGrantAudienceOverride struct { func (x *ProviderCredentialTokenGrantAudienceOverride) Reset() { *x = ProviderCredentialTokenGrantAudienceOverride{} - mi := &file_openshell_proto_msgTypes[74] + mi := &file_openshell_proto_msgTypes[72] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5427,7 +5229,7 @@ func (x *ProviderCredentialTokenGrantAudienceOverride) String() string { func (*ProviderCredentialTokenGrantAudienceOverride) ProtoMessage() {} func (x *ProviderCredentialTokenGrantAudienceOverride) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[74] + mi := &file_openshell_proto_msgTypes[72] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5440,7 +5242,7 @@ func (x *ProviderCredentialTokenGrantAudienceOverride) ProtoReflect() protorefle // Deprecated: Use ProviderCredentialTokenGrantAudienceOverride.ProtoReflect.Descriptor instead. func (*ProviderCredentialTokenGrantAudienceOverride) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{74} + return file_openshell_proto_rawDescGZIP(), []int{72} } func (x *ProviderCredentialTokenGrantAudienceOverride) GetHost() string { @@ -5505,7 +5307,7 @@ type ProviderCredentialTokenGrant struct { func (x *ProviderCredentialTokenGrant) Reset() { *x = ProviderCredentialTokenGrant{} - mi := &file_openshell_proto_msgTypes[75] + mi := &file_openshell_proto_msgTypes[73] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5517,7 +5319,7 @@ func (x *ProviderCredentialTokenGrant) String() string { func (*ProviderCredentialTokenGrant) ProtoMessage() {} func (x *ProviderCredentialTokenGrant) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[75] + mi := &file_openshell_proto_msgTypes[73] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5530,7 +5332,7 @@ func (x *ProviderCredentialTokenGrant) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialTokenGrant.ProtoReflect.Descriptor instead. func (*ProviderCredentialTokenGrant) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{75} + return file_openshell_proto_rawDescGZIP(), []int{73} } func (x *ProviderCredentialTokenGrant) GetTokenEndpoint() string { @@ -5601,7 +5403,7 @@ type ProviderProfileCredential struct { func (x *ProviderProfileCredential) Reset() { *x = ProviderProfileCredential{} - mi := &file_openshell_proto_msgTypes[76] + mi := &file_openshell_proto_msgTypes[74] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5613,7 +5415,7 @@ func (x *ProviderProfileCredential) String() string { func (*ProviderProfileCredential) ProtoMessage() {} func (x *ProviderProfileCredential) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[76] + mi := &file_openshell_proto_msgTypes[74] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5626,7 +5428,7 @@ func (x *ProviderProfileCredential) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileCredential.ProtoReflect.Descriptor instead. func (*ProviderProfileCredential) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{76} + return file_openshell_proto_rawDescGZIP(), []int{74} } func (x *ProviderProfileCredential) GetName() string { @@ -5711,7 +5513,7 @@ type ProviderCredentialRefreshMaterial struct { func (x *ProviderCredentialRefreshMaterial) Reset() { *x = ProviderCredentialRefreshMaterial{} - mi := &file_openshell_proto_msgTypes[77] + mi := &file_openshell_proto_msgTypes[75] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5723,7 +5525,7 @@ func (x *ProviderCredentialRefreshMaterial) String() string { func (*ProviderCredentialRefreshMaterial) ProtoMessage() {} func (x *ProviderCredentialRefreshMaterial) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[77] + mi := &file_openshell_proto_msgTypes[75] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5736,7 +5538,7 @@ func (x *ProviderCredentialRefreshMaterial) ProtoReflect() protoreflect.Message // Deprecated: Use ProviderCredentialRefreshMaterial.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefreshMaterial) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{77} + return file_openshell_proto_rawDescGZIP(), []int{75} } func (x *ProviderCredentialRefreshMaterial) GetName() string { @@ -5781,7 +5583,7 @@ type ProviderCredentialRefreshOutput struct { func (x *ProviderCredentialRefreshOutput) Reset() { *x = ProviderCredentialRefreshOutput{} - mi := &file_openshell_proto_msgTypes[78] + mi := &file_openshell_proto_msgTypes[76] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5793,7 +5595,7 @@ func (x *ProviderCredentialRefreshOutput) String() string { func (*ProviderCredentialRefreshOutput) ProtoMessage() {} func (x *ProviderCredentialRefreshOutput) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[78] + mi := &file_openshell_proto_msgTypes[76] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5806,7 +5608,7 @@ func (x *ProviderCredentialRefreshOutput) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialRefreshOutput.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefreshOutput) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{78} + return file_openshell_proto_rawDescGZIP(), []int{76} } func (x *ProviderCredentialRefreshOutput) GetOutput() string { @@ -5838,7 +5640,7 @@ type ProviderCredentialRefresh struct { func (x *ProviderCredentialRefresh) Reset() { *x = ProviderCredentialRefresh{} - mi := &file_openshell_proto_msgTypes[79] + mi := &file_openshell_proto_msgTypes[77] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5850,7 +5652,7 @@ func (x *ProviderCredentialRefresh) String() string { func (*ProviderCredentialRefresh) ProtoMessage() {} func (x *ProviderCredentialRefresh) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[79] + mi := &file_openshell_proto_msgTypes[77] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5863,7 +5665,7 @@ func (x *ProviderCredentialRefresh) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialRefresh.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefresh) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{79} + return file_openshell_proto_rawDescGZIP(), []int{77} } func (x *ProviderCredentialRefresh) GetStrategy() ProviderCredentialRefreshStrategy { @@ -5932,7 +5734,7 @@ type ProviderCredentialRefreshStatus struct { func (x *ProviderCredentialRefreshStatus) Reset() { *x = ProviderCredentialRefreshStatus{} - mi := &file_openshell_proto_msgTypes[80] + mi := &file_openshell_proto_msgTypes[78] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5944,7 +5746,7 @@ func (x *ProviderCredentialRefreshStatus) String() string { func (*ProviderCredentialRefreshStatus) ProtoMessage() {} func (x *ProviderCredentialRefreshStatus) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[80] + mi := &file_openshell_proto_msgTypes[78] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5957,7 +5759,7 @@ func (x *ProviderCredentialRefreshStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderCredentialRefreshStatus.ProtoReflect.Descriptor instead. func (*ProviderCredentialRefreshStatus) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{80} + return file_openshell_proto_rawDescGZIP(), []int{78} } func (x *ProviderCredentialRefreshStatus) GetProviderName() string { @@ -6034,7 +5836,7 @@ type ProviderProfileDiscovery struct { func (x *ProviderProfileDiscovery) Reset() { *x = ProviderProfileDiscovery{} - mi := &file_openshell_proto_msgTypes[81] + mi := &file_openshell_proto_msgTypes[79] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6046,7 +5848,7 @@ func (x *ProviderProfileDiscovery) String() string { func (*ProviderProfileDiscovery) ProtoMessage() {} func (x *ProviderProfileDiscovery) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[81] + mi := &file_openshell_proto_msgTypes[79] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6059,7 +5861,7 @@ func (x *ProviderProfileDiscovery) ProtoReflect() protoreflect.Message { // Deprecated: Use ProviderProfileDiscovery.ProtoReflect.Descriptor instead. func (*ProviderProfileDiscovery) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{81} + return file_openshell_proto_rawDescGZIP(), []int{79} } func (x *ProviderProfileDiscovery) GetCredentials() []string { @@ -6103,7 +5905,7 @@ type StoredProviderCredentialRefreshState struct { func (x *StoredProviderCredentialRefreshState) Reset() { *x = StoredProviderCredentialRefreshState{} - mi := &file_openshell_proto_msgTypes[82] + mi := &file_openshell_proto_msgTypes[80] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6115,7 +5917,7 @@ func (x *StoredProviderCredentialRefreshState) String() string { func (*StoredProviderCredentialRefreshState) ProtoMessage() {} func (x *StoredProviderCredentialRefreshState) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[82] + mi := &file_openshell_proto_msgTypes[80] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6128,7 +5930,7 @@ func (x *StoredProviderCredentialRefreshState) ProtoReflect() protoreflect.Messa // Deprecated: Use StoredProviderCredentialRefreshState.ProtoReflect.Descriptor instead. func (*StoredProviderCredentialRefreshState) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{82} + return file_openshell_proto_rawDescGZIP(), []int{80} } func (x *StoredProviderCredentialRefreshState) GetMetadata() *datamodelv1.ObjectMeta { @@ -6269,7 +6071,7 @@ type GetProviderRefreshStatusRequest struct { func (x *GetProviderRefreshStatusRequest) Reset() { *x = GetProviderRefreshStatusRequest{} - mi := &file_openshell_proto_msgTypes[83] + mi := &file_openshell_proto_msgTypes[81] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6281,7 +6083,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[81] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6294,7 +6096,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{81} } func (x *GetProviderRefreshStatusRequest) GetProvider() string { @@ -6327,7 +6129,7 @@ type GetProviderRefreshStatusResponse struct { func (x *GetProviderRefreshStatusResponse) Reset() { *x = GetProviderRefreshStatusResponse{} - mi := &file_openshell_proto_msgTypes[84] + mi := &file_openshell_proto_msgTypes[82] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6339,7 +6141,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[82] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6352,7 +6154,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{82} } func (x *GetProviderRefreshStatusResponse) GetCredentials() []*ProviderCredentialRefreshStatus { @@ -6378,7 +6180,7 @@ type ConfigureProviderRefreshRequest struct { func (x *ConfigureProviderRefreshRequest) Reset() { *x = ConfigureProviderRefreshRequest{} - mi := &file_openshell_proto_msgTypes[85] + mi := &file_openshell_proto_msgTypes[83] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6390,7 +6192,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[83] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6403,7 +6205,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{83} } func (x *ConfigureProviderRefreshRequest) GetProvider() string { @@ -6464,7 +6266,7 @@ type ConfigureProviderRefreshResponse struct { func (x *ConfigureProviderRefreshResponse) Reset() { *x = ConfigureProviderRefreshResponse{} - mi := &file_openshell_proto_msgTypes[86] + mi := &file_openshell_proto_msgTypes[84] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6476,7 +6278,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[84] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6489,7 +6291,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{84} } func (x *ConfigureProviderRefreshResponse) GetStatus() *ProviderCredentialRefreshStatus { @@ -6511,7 +6313,7 @@ type RotateProviderCredentialRequest struct { func (x *RotateProviderCredentialRequest) Reset() { *x = RotateProviderCredentialRequest{} - mi := &file_openshell_proto_msgTypes[87] + mi := &file_openshell_proto_msgTypes[85] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6523,7 +6325,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[85] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6536,7 +6338,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{85} } func (x *RotateProviderCredentialRequest) GetProvider() string { @@ -6569,7 +6371,7 @@ type RotateProviderCredentialResponse struct { func (x *RotateProviderCredentialResponse) Reset() { *x = RotateProviderCredentialResponse{} - mi := &file_openshell_proto_msgTypes[88] + mi := &file_openshell_proto_msgTypes[86] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6581,7 +6383,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[86] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6594,7 +6396,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{86} } func (x *RotateProviderCredentialResponse) GetStatus() *ProviderCredentialRefreshStatus { @@ -6616,7 +6418,7 @@ type DeleteProviderRefreshRequest struct { func (x *DeleteProviderRefreshRequest) Reset() { *x = DeleteProviderRefreshRequest{} - mi := &file_openshell_proto_msgTypes[89] + mi := &file_openshell_proto_msgTypes[87] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6628,7 +6430,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[87] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6641,7 +6443,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{87} } func (x *DeleteProviderRefreshRequest) GetProvider() string { @@ -6674,7 +6476,7 @@ type DeleteProviderRefreshResponse struct { func (x *DeleteProviderRefreshResponse) Reset() { *x = DeleteProviderRefreshResponse{} - mi := &file_openshell_proto_msgTypes[90] + mi := &file_openshell_proto_msgTypes[88] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6686,7 +6488,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[88] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6699,7 +6501,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{88} } func (x *DeleteProviderRefreshResponse) GetDeleted() bool { @@ -6739,7 +6541,7 @@ type ProviderProfile struct { func (x *ProviderProfile) Reset() { *x = ProviderProfile{} - mi := &file_openshell_proto_msgTypes[91] + mi := &file_openshell_proto_msgTypes[89] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6751,7 +6553,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[89] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6764,7 +6566,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{89} } func (x *ProviderProfile) GetId() string { @@ -6869,7 +6671,7 @@ type StoredProviderProfile struct { func (x *StoredProviderProfile) Reset() { *x = StoredProviderProfile{} - mi := &file_openshell_proto_msgTypes[92] + mi := &file_openshell_proto_msgTypes[90] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6881,7 +6683,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[90] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6894,7 +6696,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{90} } func (x *StoredProviderProfile) GetMetadata() *datamodelv1.ObjectMeta { @@ -6921,7 +6723,7 @@ type ProviderProfileResponse struct { func (x *ProviderProfileResponse) Reset() { *x = ProviderProfileResponse{} - mi := &file_openshell_proto_msgTypes[93] + mi := &file_openshell_proto_msgTypes[91] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6933,7 +6735,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[91] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6946,7 +6748,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{91} } func (x *ProviderProfileResponse) GetProfile() *ProviderProfile { @@ -6966,7 +6768,7 @@ type ListProviderProfilesResponse struct { func (x *ListProviderProfilesResponse) Reset() { *x = ListProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[94] + mi := &file_openshell_proto_msgTypes[92] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6978,7 +6780,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[92] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6991,7 +6793,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{92} } func (x *ListProviderProfilesResponse) GetProfiles() []*ProviderProfile { @@ -7014,7 +6816,7 @@ type ImportProviderProfilesRequest struct { func (x *ImportProviderProfilesRequest) Reset() { *x = ImportProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[95] + mi := &file_openshell_proto_msgTypes[93] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7026,7 +6828,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[93] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7039,7 +6841,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{93} } func (x *ImportProviderProfilesRequest) GetProfiles() []*ProviderProfileImportItem { @@ -7068,7 +6870,7 @@ type ImportProviderProfilesResponse struct { func (x *ImportProviderProfilesResponse) Reset() { *x = ImportProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[96] + mi := &file_openshell_proto_msgTypes[94] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7080,7 +6882,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[94] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7093,7 +6895,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{94} } func (x *ImportProviderProfilesResponse) GetDiagnostics() []*ProviderProfileDiagnostic { @@ -7137,7 +6939,7 @@ type UpdateProviderProfilesRequest struct { func (x *UpdateProviderProfilesRequest) Reset() { *x = UpdateProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[97] + mi := &file_openshell_proto_msgTypes[95] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7149,7 +6951,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[95] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7162,7 +6964,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{95} } func (x *UpdateProviderProfilesRequest) GetProfile() *ProviderProfileImportItem { @@ -7205,7 +7007,7 @@ type UpdateProviderProfilesResponse struct { func (x *UpdateProviderProfilesResponse) Reset() { *x = UpdateProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[98] + mi := &file_openshell_proto_msgTypes[96] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7217,7 +7019,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[96] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7230,7 +7032,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{96} } func (x *UpdateProviderProfilesResponse) GetDiagnostics() []*ProviderProfileDiagnostic { @@ -7267,7 +7069,7 @@ type LintProviderProfilesRequest struct { func (x *LintProviderProfilesRequest) Reset() { *x = LintProviderProfilesRequest{} - mi := &file_openshell_proto_msgTypes[99] + mi := &file_openshell_proto_msgTypes[97] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7279,7 +7081,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[97] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7292,7 +7094,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{97} } func (x *LintProviderProfilesRequest) GetProfiles() []*ProviderProfileImportItem { @@ -7320,7 +7122,7 @@ type LintProviderProfilesResponse struct { func (x *LintProviderProfilesResponse) Reset() { *x = LintProviderProfilesResponse{} - mi := &file_openshell_proto_msgTypes[100] + mi := &file_openshell_proto_msgTypes[98] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7332,7 +7134,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[98] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7345,7 +7147,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{98} } func (x *LintProviderProfilesResponse) GetDiagnostics() []*ProviderProfileDiagnostic { @@ -7372,7 +7174,7 @@ type DeleteProviderResponse struct { func (x *DeleteProviderResponse) Reset() { *x = DeleteProviderResponse{} - mi := &file_openshell_proto_msgTypes[101] + mi := &file_openshell_proto_msgTypes[99] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7384,7 +7186,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[99] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7397,7 +7199,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{99} } func (x *DeleteProviderResponse) GetDeleted() bool { @@ -7420,7 +7222,7 @@ type DeleteProviderProfileRequest struct { func (x *DeleteProviderProfileRequest) Reset() { *x = DeleteProviderProfileRequest{} - mi := &file_openshell_proto_msgTypes[102] + mi := &file_openshell_proto_msgTypes[100] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7432,7 +7234,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[100] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7445,7 +7247,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{100} } func (x *DeleteProviderProfileRequest) GetId() string { @@ -7472,7 +7274,7 @@ type DeleteProviderProfileResponse struct { func (x *DeleteProviderProfileResponse) Reset() { *x = DeleteProviderProfileResponse{} - mi := &file_openshell_proto_msgTypes[103] + mi := &file_openshell_proto_msgTypes[101] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7484,7 +7286,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[101] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7497,7 +7299,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{101} } func (x *DeleteProviderProfileResponse) GetDeleted() bool { @@ -7522,7 +7324,7 @@ type GetSandboxProviderEnvironmentRequest struct { func (x *GetSandboxProviderEnvironmentRequest) Reset() { *x = GetSandboxProviderEnvironmentRequest{} - mi := &file_openshell_proto_msgTypes[104] + mi := &file_openshell_proto_msgTypes[102] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7534,7 +7336,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[102] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7547,7 +7349,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{102} } func (x *GetSandboxProviderEnvironmentRequest) GetSandboxId() string { @@ -7576,7 +7378,7 @@ type StaticCredentialEndpointBinding struct { func (x *StaticCredentialEndpointBinding) Reset() { *x = StaticCredentialEndpointBinding{} - mi := &file_openshell_proto_msgTypes[105] + mi := &file_openshell_proto_msgTypes[103] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7588,7 +7390,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[103] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7601,7 +7403,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{103} } func (x *StaticCredentialEndpointBinding) GetHost() string { @@ -7645,7 +7447,7 @@ type StaticCredentialBinding struct { func (x *StaticCredentialBinding) Reset() { *x = StaticCredentialBinding{} - mi := &file_openshell_proto_msgTypes[106] + mi := &file_openshell_proto_msgTypes[104] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7657,7 +7459,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[104] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7670,7 +7472,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{104} } func (x *StaticCredentialBinding) GetEndpoints() []*StaticCredentialEndpointBinding { @@ -7721,7 +7523,7 @@ type GetSandboxProviderEnvironmentResponse struct { func (x *GetSandboxProviderEnvironmentResponse) Reset() { *x = GetSandboxProviderEnvironmentResponse{} - mi := &file_openshell_proto_msgTypes[107] + mi := &file_openshell_proto_msgTypes[105] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7733,7 +7535,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[105] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7746,7 +7548,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{105} } func (x *GetSandboxProviderEnvironmentResponse) GetEnvironment() map[string]string { @@ -7838,7 +7640,7 @@ type UpdateConfigRequest struct { func (x *UpdateConfigRequest) Reset() { *x = UpdateConfigRequest{} - mi := &file_openshell_proto_msgTypes[108] + mi := &file_openshell_proto_msgTypes[106] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7850,7 +7652,7 @@ func (x *UpdateConfigRequest) String() string { func (*UpdateConfigRequest) ProtoMessage() {} func (x *UpdateConfigRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[108] + mi := &file_openshell_proto_msgTypes[106] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7863,7 +7665,7 @@ func (x *UpdateConfigRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateConfigRequest.ProtoReflect.Descriptor instead. func (*UpdateConfigRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{108} + return file_openshell_proto_rawDescGZIP(), []int{106} } func (x *UpdateConfigRequest) GetName() string { @@ -7953,7 +7755,7 @@ type PolicyMergeOperation struct { func (x *PolicyMergeOperation) Reset() { *x = PolicyMergeOperation{} - mi := &file_openshell_proto_msgTypes[109] + mi := &file_openshell_proto_msgTypes[107] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7965,7 +7767,7 @@ func (x *PolicyMergeOperation) String() string { func (*PolicyMergeOperation) ProtoMessage() {} func (x *PolicyMergeOperation) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[109] + mi := &file_openshell_proto_msgTypes[107] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7978,7 +7780,7 @@ func (x *PolicyMergeOperation) ProtoReflect() protoreflect.Message { // Deprecated: Use PolicyMergeOperation.ProtoReflect.Descriptor instead. func (*PolicyMergeOperation) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{109} + return file_openshell_proto_rawDescGZIP(), []int{107} } func (x *PolicyMergeOperation) GetOperation() isPolicyMergeOperation_Operation { @@ -8092,7 +7894,7 @@ type AddNetworkRule struct { func (x *AddNetworkRule) Reset() { *x = AddNetworkRule{} - mi := &file_openshell_proto_msgTypes[110] + mi := &file_openshell_proto_msgTypes[108] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8104,7 +7906,7 @@ func (x *AddNetworkRule) String() string { func (*AddNetworkRule) ProtoMessage() {} func (x *AddNetworkRule) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[110] + mi := &file_openshell_proto_msgTypes[108] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8117,7 +7919,7 @@ func (x *AddNetworkRule) ProtoReflect() protoreflect.Message { // Deprecated: Use AddNetworkRule.ProtoReflect.Descriptor instead. func (*AddNetworkRule) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{110} + return file_openshell_proto_rawDescGZIP(), []int{108} } func (x *AddNetworkRule) GetRuleName() string { @@ -8145,7 +7947,7 @@ type RemoveNetworkEndpoint struct { func (x *RemoveNetworkEndpoint) Reset() { *x = RemoveNetworkEndpoint{} - mi := &file_openshell_proto_msgTypes[111] + mi := &file_openshell_proto_msgTypes[109] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8157,7 +7959,7 @@ func (x *RemoveNetworkEndpoint) String() string { func (*RemoveNetworkEndpoint) ProtoMessage() {} func (x *RemoveNetworkEndpoint) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[111] + mi := &file_openshell_proto_msgTypes[109] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8170,7 +7972,7 @@ func (x *RemoveNetworkEndpoint) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveNetworkEndpoint.ProtoReflect.Descriptor instead. func (*RemoveNetworkEndpoint) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{111} + return file_openshell_proto_rawDescGZIP(), []int{109} } func (x *RemoveNetworkEndpoint) GetRuleName() string { @@ -8203,7 +8005,7 @@ type RemoveNetworkRule struct { func (x *RemoveNetworkRule) Reset() { *x = RemoveNetworkRule{} - mi := &file_openshell_proto_msgTypes[112] + mi := &file_openshell_proto_msgTypes[110] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8215,7 +8017,7 @@ func (x *RemoveNetworkRule) String() string { func (*RemoveNetworkRule) ProtoMessage() {} func (x *RemoveNetworkRule) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[112] + mi := &file_openshell_proto_msgTypes[110] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8228,7 +8030,7 @@ func (x *RemoveNetworkRule) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveNetworkRule.ProtoReflect.Descriptor instead. func (*RemoveNetworkRule) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{112} + return file_openshell_proto_rawDescGZIP(), []int{110} } func (x *RemoveNetworkRule) GetRuleName() string { @@ -8249,7 +8051,7 @@ type AddDenyRules struct { func (x *AddDenyRules) Reset() { *x = AddDenyRules{} - mi := &file_openshell_proto_msgTypes[113] + mi := &file_openshell_proto_msgTypes[111] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8261,7 +8063,7 @@ func (x *AddDenyRules) String() string { func (*AddDenyRules) ProtoMessage() {} func (x *AddDenyRules) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[113] + mi := &file_openshell_proto_msgTypes[111] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8274,7 +8076,7 @@ func (x *AddDenyRules) ProtoReflect() protoreflect.Message { // Deprecated: Use AddDenyRules.ProtoReflect.Descriptor instead. func (*AddDenyRules) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{113} + return file_openshell_proto_rawDescGZIP(), []int{111} } func (x *AddDenyRules) GetHost() string { @@ -8309,7 +8111,7 @@ type AddAllowRules struct { func (x *AddAllowRules) Reset() { *x = AddAllowRules{} - mi := &file_openshell_proto_msgTypes[114] + mi := &file_openshell_proto_msgTypes[112] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8321,7 +8123,7 @@ func (x *AddAllowRules) String() string { func (*AddAllowRules) ProtoMessage() {} func (x *AddAllowRules) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[114] + mi := &file_openshell_proto_msgTypes[112] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8334,7 +8136,7 @@ func (x *AddAllowRules) ProtoReflect() protoreflect.Message { // Deprecated: Use AddAllowRules.ProtoReflect.Descriptor instead. func (*AddAllowRules) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{114} + return file_openshell_proto_rawDescGZIP(), []int{112} } func (x *AddAllowRules) GetHost() string { @@ -8368,7 +8170,7 @@ type RemoveNetworkBinary struct { func (x *RemoveNetworkBinary) Reset() { *x = RemoveNetworkBinary{} - mi := &file_openshell_proto_msgTypes[115] + mi := &file_openshell_proto_msgTypes[113] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8380,7 +8182,7 @@ func (x *RemoveNetworkBinary) String() string { func (*RemoveNetworkBinary) ProtoMessage() {} func (x *RemoveNetworkBinary) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[115] + mi := &file_openshell_proto_msgTypes[113] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8393,7 +8195,7 @@ func (x *RemoveNetworkBinary) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveNetworkBinary.ProtoReflect.Descriptor instead. func (*RemoveNetworkBinary) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{115} + return file_openshell_proto_rawDescGZIP(), []int{113} } func (x *RemoveNetworkBinary) GetRuleName() string { @@ -8429,7 +8231,7 @@ type UpdateConfigResponse struct { func (x *UpdateConfigResponse) Reset() { *x = UpdateConfigResponse{} - mi := &file_openshell_proto_msgTypes[116] + mi := &file_openshell_proto_msgTypes[114] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8441,7 +8243,7 @@ func (x *UpdateConfigResponse) String() string { func (*UpdateConfigResponse) ProtoMessage() {} func (x *UpdateConfigResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[116] + mi := &file_openshell_proto_msgTypes[114] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8454,7 +8256,7 @@ func (x *UpdateConfigResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateConfigResponse.ProtoReflect.Descriptor instead. func (*UpdateConfigResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{116} + return file_openshell_proto_rawDescGZIP(), []int{114} } func (x *UpdateConfigResponse) GetVersion() uint32 { @@ -8509,7 +8311,7 @@ type GetSandboxPolicyStatusRequest struct { func (x *GetSandboxPolicyStatusRequest) Reset() { *x = GetSandboxPolicyStatusRequest{} - mi := &file_openshell_proto_msgTypes[117] + mi := &file_openshell_proto_msgTypes[115] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8521,7 +8323,7 @@ func (x *GetSandboxPolicyStatusRequest) String() string { func (*GetSandboxPolicyStatusRequest) ProtoMessage() {} func (x *GetSandboxPolicyStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[117] + mi := &file_openshell_proto_msgTypes[115] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8534,7 +8336,7 @@ func (x *GetSandboxPolicyStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxPolicyStatusRequest.ProtoReflect.Descriptor instead. func (*GetSandboxPolicyStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{117} + return file_openshell_proto_rawDescGZIP(), []int{115} } func (x *GetSandboxPolicyStatusRequest) GetName() string { @@ -8578,7 +8380,7 @@ type GetSandboxPolicyStatusResponse struct { func (x *GetSandboxPolicyStatusResponse) Reset() { *x = GetSandboxPolicyStatusResponse{} - mi := &file_openshell_proto_msgTypes[118] + mi := &file_openshell_proto_msgTypes[116] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8590,7 +8392,7 @@ func (x *GetSandboxPolicyStatusResponse) String() string { func (*GetSandboxPolicyStatusResponse) ProtoMessage() {} func (x *GetSandboxPolicyStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[118] + mi := &file_openshell_proto_msgTypes[116] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8603,7 +8405,7 @@ func (x *GetSandboxPolicyStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxPolicyStatusResponse.ProtoReflect.Descriptor instead. func (*GetSandboxPolicyStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{118} + return file_openshell_proto_rawDescGZIP(), []int{116} } func (x *GetSandboxPolicyStatusResponse) GetRevision() *SandboxPolicyRevision { @@ -8637,7 +8439,7 @@ type ListSandboxPoliciesRequest struct { func (x *ListSandboxPoliciesRequest) Reset() { *x = ListSandboxPoliciesRequest{} - mi := &file_openshell_proto_msgTypes[119] + mi := &file_openshell_proto_msgTypes[117] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8649,7 +8451,7 @@ func (x *ListSandboxPoliciesRequest) String() string { func (*ListSandboxPoliciesRequest) ProtoMessage() {} func (x *ListSandboxPoliciesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[119] + mi := &file_openshell_proto_msgTypes[117] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8662,7 +8464,7 @@ func (x *ListSandboxPoliciesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxPoliciesRequest.ProtoReflect.Descriptor instead. func (*ListSandboxPoliciesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{119} + return file_openshell_proto_rawDescGZIP(), []int{117} } func (x *ListSandboxPoliciesRequest) GetName() string { @@ -8710,7 +8512,7 @@ type ListSandboxPoliciesResponse struct { func (x *ListSandboxPoliciesResponse) Reset() { *x = ListSandboxPoliciesResponse{} - mi := &file_openshell_proto_msgTypes[120] + mi := &file_openshell_proto_msgTypes[118] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8722,7 +8524,7 @@ func (x *ListSandboxPoliciesResponse) String() string { func (*ListSandboxPoliciesResponse) ProtoMessage() {} func (x *ListSandboxPoliciesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[120] + mi := &file_openshell_proto_msgTypes[118] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8735,7 +8537,7 @@ func (x *ListSandboxPoliciesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListSandboxPoliciesResponse.ProtoReflect.Descriptor instead. func (*ListSandboxPoliciesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{120} + return file_openshell_proto_rawDescGZIP(), []int{118} } func (x *ListSandboxPoliciesResponse) GetRevisions() []*SandboxPolicyRevision { @@ -8762,7 +8564,7 @@ type ReportPolicyStatusRequest struct { func (x *ReportPolicyStatusRequest) Reset() { *x = ReportPolicyStatusRequest{} - mi := &file_openshell_proto_msgTypes[121] + mi := &file_openshell_proto_msgTypes[119] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8774,7 +8576,7 @@ func (x *ReportPolicyStatusRequest) String() string { func (*ReportPolicyStatusRequest) ProtoMessage() {} func (x *ReportPolicyStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[121] + mi := &file_openshell_proto_msgTypes[119] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8787,7 +8589,7 @@ func (x *ReportPolicyStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportPolicyStatusRequest.ProtoReflect.Descriptor instead. func (*ReportPolicyStatusRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{121} + return file_openshell_proto_rawDescGZIP(), []int{119} } func (x *ReportPolicyStatusRequest) GetSandboxId() string { @@ -8827,7 +8629,7 @@ type ReportPolicyStatusResponse struct { func (x *ReportPolicyStatusResponse) Reset() { *x = ReportPolicyStatusResponse{} - mi := &file_openshell_proto_msgTypes[122] + mi := &file_openshell_proto_msgTypes[120] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8839,7 +8641,7 @@ func (x *ReportPolicyStatusResponse) String() string { func (*ReportPolicyStatusResponse) ProtoMessage() {} func (x *ReportPolicyStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[122] + mi := &file_openshell_proto_msgTypes[120] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8852,7 +8654,7 @@ func (x *ReportPolicyStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportPolicyStatusResponse.ProtoReflect.Descriptor instead. func (*ReportPolicyStatusResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{122} + return file_openshell_proto_rawDescGZIP(), []int{120} } // A versioned policy revision with metadata. @@ -8880,7 +8682,7 @@ type SandboxPolicyRevision struct { func (x *SandboxPolicyRevision) Reset() { *x = SandboxPolicyRevision{} - mi := &file_openshell_proto_msgTypes[123] + mi := &file_openshell_proto_msgTypes[121] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8892,7 +8694,7 @@ func (x *SandboxPolicyRevision) String() string { func (*SandboxPolicyRevision) ProtoMessage() {} func (x *SandboxPolicyRevision) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[123] + mi := &file_openshell_proto_msgTypes[121] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8905,7 +8707,7 @@ func (x *SandboxPolicyRevision) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxPolicyRevision.ProtoReflect.Descriptor instead. func (*SandboxPolicyRevision) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{123} + return file_openshell_proto_rawDescGZIP(), []int{121} } func (x *SandboxPolicyRevision) GetVersion() uint32 { @@ -8985,7 +8787,7 @@ type GetSandboxLogsRequest struct { func (x *GetSandboxLogsRequest) Reset() { *x = GetSandboxLogsRequest{} - mi := &file_openshell_proto_msgTypes[124] + mi := &file_openshell_proto_msgTypes[122] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8997,7 +8799,7 @@ func (x *GetSandboxLogsRequest) String() string { func (*GetSandboxLogsRequest) ProtoMessage() {} func (x *GetSandboxLogsRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[124] + mi := &file_openshell_proto_msgTypes[122] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9010,7 +8812,7 @@ func (x *GetSandboxLogsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxLogsRequest.ProtoReflect.Descriptor instead. func (*GetSandboxLogsRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{124} + return file_openshell_proto_rawDescGZIP(), []int{122} } func (x *GetSandboxLogsRequest) GetSandboxId() string { @@ -9068,7 +8870,7 @@ type PushSandboxLogsRequest struct { func (x *PushSandboxLogsRequest) Reset() { *x = PushSandboxLogsRequest{} - mi := &file_openshell_proto_msgTypes[125] + mi := &file_openshell_proto_msgTypes[123] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9080,7 +8882,7 @@ func (x *PushSandboxLogsRequest) String() string { func (*PushSandboxLogsRequest) ProtoMessage() {} func (x *PushSandboxLogsRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[125] + mi := &file_openshell_proto_msgTypes[123] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9093,7 +8895,7 @@ func (x *PushSandboxLogsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use PushSandboxLogsRequest.ProtoReflect.Descriptor instead. func (*PushSandboxLogsRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{125} + return file_openshell_proto_rawDescGZIP(), []int{123} } func (x *PushSandboxLogsRequest) GetSandboxId() string { @@ -9119,7 +8921,7 @@ type PushSandboxLogsResponse struct { func (x *PushSandboxLogsResponse) Reset() { *x = PushSandboxLogsResponse{} - mi := &file_openshell_proto_msgTypes[126] + mi := &file_openshell_proto_msgTypes[124] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9131,7 +8933,7 @@ func (x *PushSandboxLogsResponse) String() string { func (*PushSandboxLogsResponse) ProtoMessage() {} func (x *PushSandboxLogsResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[126] + mi := &file_openshell_proto_msgTypes[124] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9144,7 +8946,7 @@ func (x *PushSandboxLogsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use PushSandboxLogsResponse.ProtoReflect.Descriptor instead. func (*PushSandboxLogsResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{126} + return file_openshell_proto_rawDescGZIP(), []int{124} } // Get sandbox logs response. @@ -9160,7 +8962,7 @@ type GetSandboxLogsResponse struct { func (x *GetSandboxLogsResponse) Reset() { *x = GetSandboxLogsResponse{} - mi := &file_openshell_proto_msgTypes[127] + mi := &file_openshell_proto_msgTypes[125] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9172,7 +8974,7 @@ func (x *GetSandboxLogsResponse) String() string { func (*GetSandboxLogsResponse) ProtoMessage() {} func (x *GetSandboxLogsResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[127] + mi := &file_openshell_proto_msgTypes[125] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9185,7 +8987,7 @@ func (x *GetSandboxLogsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSandboxLogsResponse.ProtoReflect.Descriptor instead. func (*GetSandboxLogsResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{127} + return file_openshell_proto_rawDescGZIP(), []int{125} } func (x *GetSandboxLogsResponse) GetLogs() []*SandboxLogLine { @@ -9211,7 +9013,6 @@ type SupervisorMessage struct { // *SupervisorMessage_Heartbeat // *SupervisorMessage_RelayOpenResult // *SupervisorMessage_RelayClose - // *SupervisorMessage_MainProcessExit Payload isSupervisorMessage_Payload `protobuf_oneof:"payload"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache @@ -9219,7 +9020,7 @@ type SupervisorMessage struct { func (x *SupervisorMessage) Reset() { *x = SupervisorMessage{} - mi := &file_openshell_proto_msgTypes[128] + mi := &file_openshell_proto_msgTypes[126] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9231,7 +9032,7 @@ func (x *SupervisorMessage) String() string { func (*SupervisorMessage) ProtoMessage() {} func (x *SupervisorMessage) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[128] + mi := &file_openshell_proto_msgTypes[126] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9244,7 +9045,7 @@ func (x *SupervisorMessage) ProtoReflect() protoreflect.Message { // Deprecated: Use SupervisorMessage.ProtoReflect.Descriptor instead. func (*SupervisorMessage) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{128} + return file_openshell_proto_rawDescGZIP(), []int{126} } func (x *SupervisorMessage) GetPayload() isSupervisorMessage_Payload { @@ -9290,15 +9091,6 @@ func (x *SupervisorMessage) GetRelayClose() *RelayClose { return nil } -func (x *SupervisorMessage) GetMainProcessExit() *MainProcessExit { - if x != nil { - if x, ok := x.Payload.(*SupervisorMessage_MainProcessExit); ok { - return x.MainProcessExit - } - } - return nil -} - type isSupervisorMessage_Payload interface { isSupervisorMessage_Payload() } @@ -9319,10 +9111,6 @@ type SupervisorMessage_RelayClose struct { RelayClose *RelayClose `protobuf:"bytes,4,opt,name=relay_close,json=relayClose,proto3,oneof"` } -type SupervisorMessage_MainProcessExit struct { - MainProcessExit *MainProcessExit `protobuf:"bytes,5,opt,name=main_process_exit,json=mainProcessExit,proto3,oneof"` -} - func (*SupervisorMessage_Hello) isSupervisorMessage_Payload() {} func (*SupervisorMessage_Heartbeat) isSupervisorMessage_Payload() {} @@ -9331,8 +9119,6 @@ func (*SupervisorMessage_RelayOpenResult) isSupervisorMessage_Payload() {} func (*SupervisorMessage_RelayClose) isSupervisorMessage_Payload() {} -func (*SupervisorMessage_MainProcessExit) isSupervisorMessage_Payload() {} - // Envelope for gateway-to-supervisor messages on the ConnectSupervisor stream. type GatewayMessage struct { state protoimpl.MessageState `protogen:"open.v1"` @@ -9343,7 +9129,6 @@ type GatewayMessage struct { // *GatewayMessage_Heartbeat // *GatewayMessage_RelayOpen // *GatewayMessage_RelayClose - // *GatewayMessage_MainProcessExitAck Payload isGatewayMessage_Payload `protobuf_oneof:"payload"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache @@ -9351,7 +9136,7 @@ type GatewayMessage struct { func (x *GatewayMessage) Reset() { *x = GatewayMessage{} - mi := &file_openshell_proto_msgTypes[129] + mi := &file_openshell_proto_msgTypes[127] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9363,7 +9148,7 @@ func (x *GatewayMessage) String() string { func (*GatewayMessage) ProtoMessage() {} func (x *GatewayMessage) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[129] + mi := &file_openshell_proto_msgTypes[127] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9376,7 +9161,7 @@ func (x *GatewayMessage) ProtoReflect() protoreflect.Message { // Deprecated: Use GatewayMessage.ProtoReflect.Descriptor instead. func (*GatewayMessage) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{129} + return file_openshell_proto_rawDescGZIP(), []int{127} } func (x *GatewayMessage) GetPayload() isGatewayMessage_Payload { @@ -9431,15 +9216,6 @@ func (x *GatewayMessage) GetRelayClose() *RelayClose { return nil } -func (x *GatewayMessage) GetMainProcessExitAck() *MainProcessExitAck { - if x != nil { - if x, ok := x.Payload.(*GatewayMessage_MainProcessExitAck); ok { - return x.MainProcessExitAck - } - } - return nil -} - type isGatewayMessage_Payload interface { isGatewayMessage_Payload() } @@ -9464,10 +9240,6 @@ type GatewayMessage_RelayClose struct { RelayClose *RelayClose `protobuf:"bytes,5,opt,name=relay_close,json=relayClose,proto3,oneof"` } -type GatewayMessage_MainProcessExitAck struct { - MainProcessExitAck *MainProcessExitAck `protobuf:"bytes,6,opt,name=main_process_exit_ack,json=mainProcessExitAck,proto3,oneof"` -} - func (*GatewayMessage_SessionAccepted) isGatewayMessage_Payload() {} func (*GatewayMessage_SessionRejected) isGatewayMessage_Payload() {} @@ -9478,25 +9250,20 @@ func (*GatewayMessage_RelayOpen) isGatewayMessage_Payload() {} func (*GatewayMessage_RelayClose) isGatewayMessage_Payload() {} -func (*GatewayMessage_MainProcessExitAck) isGatewayMessage_Payload() {} - // Supervisor identifies itself and the sandbox it manages. type SupervisorHello struct { state protoimpl.MessageState `protogen:"open.v1"` // Sandbox ID this supervisor manages. SandboxId string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` // Supervisor instance ID (e.g. boot id or process epoch). - InstanceId string `protobuf:"bytes,2,opt,name=instance_id,json=instanceId,proto3" json:"instance_id,omitempty"` - // Short-lived terminal-result sessions authenticate an existing generation - // but must not replace the active relay session or advertise readiness. - ExitReportOnly bool `protobuf:"varint,3,opt,name=exit_report_only,json=exitReportOnly,proto3" json:"exit_report_only,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + InstanceId string `protobuf:"bytes,2,opt,name=instance_id,json=instanceId,proto3" json:"instance_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *SupervisorHello) Reset() { *x = SupervisorHello{} - mi := &file_openshell_proto_msgTypes[130] + mi := &file_openshell_proto_msgTypes[128] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9508,7 +9275,7 @@ func (x *SupervisorHello) String() string { func (*SupervisorHello) ProtoMessage() {} func (x *SupervisorHello) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[130] + mi := &file_openshell_proto_msgTypes[128] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9521,7 +9288,7 @@ func (x *SupervisorHello) ProtoReflect() protoreflect.Message { // Deprecated: Use SupervisorHello.ProtoReflect.Descriptor instead. func (*SupervisorHello) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{130} + return file_openshell_proto_rawDescGZIP(), []int{128} } func (x *SupervisorHello) GetSandboxId() string { @@ -9538,13 +9305,6 @@ func (x *SupervisorHello) GetInstanceId() string { return "" } -func (x *SupervisorHello) GetExitReportOnly() bool { - if x != nil { - return x.ExitReportOnly - } - return false -} - // Gateway accepts the supervisor session. type SessionAccepted struct { state protoimpl.MessageState `protogen:"open.v1"` @@ -9558,7 +9318,7 @@ type SessionAccepted struct { func (x *SessionAccepted) Reset() { *x = SessionAccepted{} - mi := &file_openshell_proto_msgTypes[131] + mi := &file_openshell_proto_msgTypes[129] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9570,7 +9330,7 @@ func (x *SessionAccepted) String() string { func (*SessionAccepted) ProtoMessage() {} func (x *SessionAccepted) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[131] + mi := &file_openshell_proto_msgTypes[129] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9583,7 +9343,7 @@ func (x *SessionAccepted) ProtoReflect() protoreflect.Message { // Deprecated: Use SessionAccepted.ProtoReflect.Descriptor instead. func (*SessionAccepted) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{131} + return file_openshell_proto_rawDescGZIP(), []int{129} } func (x *SessionAccepted) GetSessionId() string { @@ -9611,7 +9371,7 @@ type SessionRejected struct { func (x *SessionRejected) Reset() { *x = SessionRejected{} - mi := &file_openshell_proto_msgTypes[132] + mi := &file_openshell_proto_msgTypes[130] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9623,7 +9383,7 @@ func (x *SessionRejected) String() string { func (*SessionRejected) ProtoMessage() {} func (x *SessionRejected) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[132] + mi := &file_openshell_proto_msgTypes[130] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9636,7 +9396,7 @@ func (x *SessionRejected) ProtoReflect() protoreflect.Message { // Deprecated: Use SessionRejected.ProtoReflect.Descriptor instead. func (*SessionRejected) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{132} + return file_openshell_proto_rawDescGZIP(), []int{130} } func (x *SessionRejected) GetReason() string { @@ -9655,7 +9415,7 @@ type SupervisorHeartbeat struct { func (x *SupervisorHeartbeat) Reset() { *x = SupervisorHeartbeat{} - mi := &file_openshell_proto_msgTypes[133] + mi := &file_openshell_proto_msgTypes[131] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9667,7 +9427,7 @@ func (x *SupervisorHeartbeat) String() string { func (*SupervisorHeartbeat) ProtoMessage() {} func (x *SupervisorHeartbeat) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[133] + mi := &file_openshell_proto_msgTypes[131] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9680,7 +9440,7 @@ func (x *SupervisorHeartbeat) ProtoReflect() protoreflect.Message { // Deprecated: Use SupervisorHeartbeat.ProtoReflect.Descriptor instead. func (*SupervisorHeartbeat) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{133} + return file_openshell_proto_rawDescGZIP(), []int{131} } // Gateway heartbeat. @@ -9692,7 +9452,7 @@ type GatewayHeartbeat struct { func (x *GatewayHeartbeat) Reset() { *x = GatewayHeartbeat{} - mi := &file_openshell_proto_msgTypes[134] + mi := &file_openshell_proto_msgTypes[132] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9704,7 +9464,7 @@ func (x *GatewayHeartbeat) String() string { func (*GatewayHeartbeat) ProtoMessage() {} func (x *GatewayHeartbeat) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[134] + mi := &file_openshell_proto_msgTypes[132] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9717,37 +9477,36 @@ func (x *GatewayHeartbeat) ProtoReflect() protoreflect.Message { // Deprecated: Use GatewayHeartbeat.ProtoReflect.Descriptor instead. func (*GatewayHeartbeat) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{134} + return file_openshell_proto_rawDescGZIP(), []int{132} } -// Terminal result reported before the supervisor shuts down. A missing exit -// code with a present signal represents signal termination. -type MainProcessExit struct { - state protoimpl.MessageState `protogen:"open.v1"` - Generation string `protobuf:"bytes,1,opt,name=generation,proto3" json:"generation,omitempty"` - ExitCode *int32 `protobuf:"varint,2,opt,name=exit_code,json=exitCode,proto3,oneof" json:"exit_code,omitempty"` - Signal *int32 `protobuf:"varint,3,opt,name=signal,proto3,oneof" json:"signal,omitempty"` - StartedAtMs int64 `protobuf:"varint,4,opt,name=started_at_ms,json=startedAtMs,proto3" json:"started_at_ms,omitempty"` - FinishedAtMs int64 `protobuf:"varint,5,opt,name=finished_at_ms,json=finishedAtMs,proto3" json:"finished_at_ms,omitempty"` +// Terminal result reported before the supervisor shuts down. A successful RPC +// response confirms that the result was durably handled by the gateway. +type ReportMainProcessExitRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + SandboxId string `protobuf:"bytes,1,opt,name=sandbox_id,json=sandboxId,proto3" json:"sandbox_id,omitempty"` + InstanceId string `protobuf:"bytes,2,opt,name=instance_id,json=instanceId,proto3" json:"instance_id,omitempty"` + // Normalized process result. Signal exits use 128 + signal number. + ExitCode int32 `protobuf:"varint,3,opt,name=exit_code,json=exitCode,proto3" json:"exit_code,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *MainProcessExit) Reset() { - *x = MainProcessExit{} - mi := &file_openshell_proto_msgTypes[135] +func (x *ReportMainProcessExitRequest) Reset() { + *x = ReportMainProcessExitRequest{} + mi := &file_openshell_proto_msgTypes[133] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *MainProcessExit) String() string { +func (x *ReportMainProcessExitRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*MainProcessExit) ProtoMessage() {} +func (*ReportMainProcessExitRequest) ProtoMessage() {} -func (x *MainProcessExit) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[135] +func (x *ReportMainProcessExitRequest) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[133] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9758,69 +9517,53 @@ func (x *MainProcessExit) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use MainProcessExit.ProtoReflect.Descriptor instead. -func (*MainProcessExit) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{135} +// Deprecated: Use ReportMainProcessExitRequest.ProtoReflect.Descriptor instead. +func (*ReportMainProcessExitRequest) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{133} } -func (x *MainProcessExit) GetGeneration() string { +func (x *ReportMainProcessExitRequest) GetSandboxId() string { if x != nil { - return x.Generation + return x.SandboxId } return "" } -func (x *MainProcessExit) GetExitCode() int32 { - if x != nil && x.ExitCode != nil { - return *x.ExitCode - } - return 0 -} - -func (x *MainProcessExit) GetSignal() int32 { - if x != nil && x.Signal != nil { - return *x.Signal - } - return 0 -} - -func (x *MainProcessExit) GetStartedAtMs() int64 { +func (x *ReportMainProcessExitRequest) GetInstanceId() string { if x != nil { - return x.StartedAtMs + return x.InstanceId } - return 0 + return "" } -func (x *MainProcessExit) GetFinishedAtMs() int64 { +func (x *ReportMainProcessExitRequest) GetExitCode() int32 { if x != nil { - return x.FinishedAtMs + return x.ExitCode } return 0 } -// Gateway acknowledgement that the terminal result has been durably handled. -type MainProcessExitAck struct { +type ReportMainProcessExitResponse struct { state protoimpl.MessageState `protogen:"open.v1"` - Generation string `protobuf:"bytes,1,opt,name=generation,proto3" json:"generation,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *MainProcessExitAck) Reset() { - *x = MainProcessExitAck{} - mi := &file_openshell_proto_msgTypes[136] +func (x *ReportMainProcessExitResponse) Reset() { + *x = ReportMainProcessExitResponse{} + mi := &file_openshell_proto_msgTypes[134] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *MainProcessExitAck) String() string { +func (x *ReportMainProcessExitResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*MainProcessExitAck) ProtoMessage() {} +func (*ReportMainProcessExitResponse) ProtoMessage() {} -func (x *MainProcessExitAck) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[136] +func (x *ReportMainProcessExitResponse) ProtoReflect() protoreflect.Message { + mi := &file_openshell_proto_msgTypes[134] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9831,16 +9574,9 @@ func (x *MainProcessExitAck) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use MainProcessExitAck.ProtoReflect.Descriptor instead. -func (*MainProcessExitAck) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{136} -} - -func (x *MainProcessExitAck) GetGeneration() string { - if x != nil { - return x.Generation - } - return "" +// Deprecated: Use ReportMainProcessExitResponse.ProtoReflect.Descriptor instead. +func (*ReportMainProcessExitResponse) Descriptor() ([]byte, []int) { + return file_openshell_proto_rawDescGZIP(), []int{134} } // Gateway requests the supervisor to open a relay channel. @@ -9869,7 +9605,7 @@ type RelayOpen struct { func (x *RelayOpen) Reset() { *x = RelayOpen{} - mi := &file_openshell_proto_msgTypes[137] + mi := &file_openshell_proto_msgTypes[135] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9881,7 +9617,7 @@ func (x *RelayOpen) String() string { func (*RelayOpen) ProtoMessage() {} func (x *RelayOpen) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[137] + mi := &file_openshell_proto_msgTypes[135] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9894,7 +9630,7 @@ func (x *RelayOpen) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayOpen.ProtoReflect.Descriptor instead. func (*RelayOpen) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{137} + return file_openshell_proto_rawDescGZIP(), []int{135} } func (x *RelayOpen) GetChannelId() string { @@ -9961,7 +9697,7 @@ type SshRelayTarget struct { func (x *SshRelayTarget) Reset() { *x = SshRelayTarget{} - mi := &file_openshell_proto_msgTypes[138] + mi := &file_openshell_proto_msgTypes[136] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9973,7 +9709,7 @@ func (x *SshRelayTarget) String() string { func (*SshRelayTarget) ProtoMessage() {} func (x *SshRelayTarget) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[138] + mi := &file_openshell_proto_msgTypes[136] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9986,7 +9722,7 @@ func (x *SshRelayTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use SshRelayTarget.ProtoReflect.Descriptor instead. func (*SshRelayTarget) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{138} + return file_openshell_proto_rawDescGZIP(), []int{136} } // TCP target dialed by the supervisor from inside the sandbox. @@ -10002,7 +9738,7 @@ type TcpRelayTarget struct { func (x *TcpRelayTarget) Reset() { *x = TcpRelayTarget{} - mi := &file_openshell_proto_msgTypes[139] + mi := &file_openshell_proto_msgTypes[137] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10014,7 +9750,7 @@ func (x *TcpRelayTarget) String() string { func (*TcpRelayTarget) ProtoMessage() {} func (x *TcpRelayTarget) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[139] + mi := &file_openshell_proto_msgTypes[137] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10027,7 +9763,7 @@ func (x *TcpRelayTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use TcpRelayTarget.ProtoReflect.Descriptor instead. func (*TcpRelayTarget) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{139} + return file_openshell_proto_rawDescGZIP(), []int{137} } func (x *TcpRelayTarget) GetHost() string { @@ -10055,7 +9791,7 @@ type RelayInit struct { func (x *RelayInit) Reset() { *x = RelayInit{} - mi := &file_openshell_proto_msgTypes[140] + mi := &file_openshell_proto_msgTypes[138] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10067,7 +9803,7 @@ func (x *RelayInit) String() string { func (*RelayInit) ProtoMessage() {} func (x *RelayInit) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[140] + mi := &file_openshell_proto_msgTypes[138] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10080,7 +9816,7 @@ func (x *RelayInit) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayInit.ProtoReflect.Descriptor instead. func (*RelayInit) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{140} + return file_openshell_proto_rawDescGZIP(), []int{138} } func (x *RelayInit) GetChannelId() string { @@ -10107,7 +9843,7 @@ type RelayFrame struct { func (x *RelayFrame) Reset() { *x = RelayFrame{} - mi := &file_openshell_proto_msgTypes[141] + mi := &file_openshell_proto_msgTypes[139] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10119,7 +9855,7 @@ func (x *RelayFrame) String() string { func (*RelayFrame) ProtoMessage() {} func (x *RelayFrame) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[141] + mi := &file_openshell_proto_msgTypes[139] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10132,7 +9868,7 @@ func (x *RelayFrame) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayFrame.ProtoReflect.Descriptor instead. func (*RelayFrame) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{141} + return file_openshell_proto_rawDescGZIP(), []int{139} } func (x *RelayFrame) GetPayload() isRelayFrame_Payload { @@ -10191,7 +9927,7 @@ type RelayOpenResult struct { func (x *RelayOpenResult) Reset() { *x = RelayOpenResult{} - mi := &file_openshell_proto_msgTypes[142] + mi := &file_openshell_proto_msgTypes[140] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10203,7 +9939,7 @@ func (x *RelayOpenResult) String() string { func (*RelayOpenResult) ProtoMessage() {} func (x *RelayOpenResult) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[142] + mi := &file_openshell_proto_msgTypes[140] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10216,7 +9952,7 @@ func (x *RelayOpenResult) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayOpenResult.ProtoReflect.Descriptor instead. func (*RelayOpenResult) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{142} + return file_openshell_proto_rawDescGZIP(), []int{140} } func (x *RelayOpenResult) GetChannelId() string { @@ -10253,7 +9989,7 @@ type RelayClose struct { func (x *RelayClose) Reset() { *x = RelayClose{} - mi := &file_openshell_proto_msgTypes[143] + mi := &file_openshell_proto_msgTypes[141] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10265,7 +10001,7 @@ func (x *RelayClose) String() string { func (*RelayClose) ProtoMessage() {} func (x *RelayClose) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[143] + mi := &file_openshell_proto_msgTypes[141] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10278,7 +10014,7 @@ func (x *RelayClose) ProtoReflect() protoreflect.Message { // Deprecated: Use RelayClose.ProtoReflect.Descriptor instead. func (*RelayClose) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{143} + return file_openshell_proto_rawDescGZIP(), []int{141} } func (x *RelayClose) GetChannelId() string { @@ -10312,7 +10048,7 @@ type L7RequestSample struct { func (x *L7RequestSample) Reset() { *x = L7RequestSample{} - mi := &file_openshell_proto_msgTypes[144] + mi := &file_openshell_proto_msgTypes[142] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10324,7 +10060,7 @@ func (x *L7RequestSample) String() string { func (*L7RequestSample) ProtoMessage() {} func (x *L7RequestSample) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[144] + mi := &file_openshell_proto_msgTypes[142] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10337,7 +10073,7 @@ func (x *L7RequestSample) ProtoReflect() protoreflect.Message { // Deprecated: Use L7RequestSample.ProtoReflect.Descriptor instead. func (*L7RequestSample) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{144} + return file_openshell_proto_rawDescGZIP(), []int{142} } func (x *L7RequestSample) GetMethod() string { @@ -10411,7 +10147,7 @@ type DenialSummary struct { func (x *DenialSummary) Reset() { *x = DenialSummary{} - mi := &file_openshell_proto_msgTypes[145] + mi := &file_openshell_proto_msgTypes[143] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10423,7 +10159,7 @@ func (x *DenialSummary) String() string { func (*DenialSummary) ProtoMessage() {} func (x *DenialSummary) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[145] + mi := &file_openshell_proto_msgTypes[143] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10436,7 +10172,7 @@ func (x *DenialSummary) ProtoReflect() protoreflect.Message { // Deprecated: Use DenialSummary.ProtoReflect.Descriptor instead. func (*DenialSummary) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{145} + return file_openshell_proto_rawDescGZIP(), []int{143} } func (x *DenialSummary) GetSandboxId() string { @@ -10571,7 +10307,7 @@ type DenialGroupCount struct { func (x *DenialGroupCount) Reset() { *x = DenialGroupCount{} - mi := &file_openshell_proto_msgTypes[146] + mi := &file_openshell_proto_msgTypes[144] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10583,7 +10319,7 @@ func (x *DenialGroupCount) String() string { func (*DenialGroupCount) ProtoMessage() {} func (x *DenialGroupCount) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[146] + mi := &file_openshell_proto_msgTypes[144] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10596,7 +10332,7 @@ func (x *DenialGroupCount) ProtoReflect() protoreflect.Message { // Deprecated: Use DenialGroupCount.ProtoReflect.Descriptor instead. func (*DenialGroupCount) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{146} + return file_openshell_proto_rawDescGZIP(), []int{144} } func (x *DenialGroupCount) GetDenyGroup() string { @@ -10629,7 +10365,7 @@ type NetworkActivitySummary struct { func (x *NetworkActivitySummary) Reset() { *x = NetworkActivitySummary{} - mi := &file_openshell_proto_msgTypes[147] + mi := &file_openshell_proto_msgTypes[145] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10641,7 +10377,7 @@ func (x *NetworkActivitySummary) String() string { func (*NetworkActivitySummary) ProtoMessage() {} func (x *NetworkActivitySummary) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[147] + mi := &file_openshell_proto_msgTypes[145] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10654,7 +10390,7 @@ func (x *NetworkActivitySummary) ProtoReflect() protoreflect.Message { // Deprecated: Use NetworkActivitySummary.ProtoReflect.Descriptor instead. func (*NetworkActivitySummary) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{147} + return file_openshell_proto_rawDescGZIP(), []int{145} } func (x *NetworkActivitySummary) GetNetworkActivityCount() uint32 { @@ -10728,7 +10464,7 @@ type PolicyChunk struct { func (x *PolicyChunk) Reset() { *x = PolicyChunk{} - mi := &file_openshell_proto_msgTypes[148] + mi := &file_openshell_proto_msgTypes[146] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10740,7 +10476,7 @@ func (x *PolicyChunk) String() string { func (*PolicyChunk) ProtoMessage() {} func (x *PolicyChunk) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[148] + mi := &file_openshell_proto_msgTypes[146] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10753,7 +10489,7 @@ func (x *PolicyChunk) ProtoReflect() protoreflect.Message { // Deprecated: Use PolicyChunk.ProtoReflect.Descriptor instead. func (*PolicyChunk) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{148} + return file_openshell_proto_rawDescGZIP(), []int{146} } func (x *PolicyChunk) GetId() string { @@ -10899,7 +10635,7 @@ type DraftPolicyUpdate struct { func (x *DraftPolicyUpdate) Reset() { *x = DraftPolicyUpdate{} - mi := &file_openshell_proto_msgTypes[149] + mi := &file_openshell_proto_msgTypes[147] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10911,7 +10647,7 @@ func (x *DraftPolicyUpdate) String() string { func (*DraftPolicyUpdate) ProtoMessage() {} func (x *DraftPolicyUpdate) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[149] + mi := &file_openshell_proto_msgTypes[147] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10924,7 +10660,7 @@ func (x *DraftPolicyUpdate) ProtoReflect() protoreflect.Message { // Deprecated: Use DraftPolicyUpdate.ProtoReflect.Descriptor instead. func (*DraftPolicyUpdate) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{149} + return file_openshell_proto_rawDescGZIP(), []int{147} } func (x *DraftPolicyUpdate) GetDraftVersion() uint64 { @@ -10982,7 +10718,7 @@ type SubmitPolicyAnalysisRequest struct { func (x *SubmitPolicyAnalysisRequest) Reset() { *x = SubmitPolicyAnalysisRequest{} - mi := &file_openshell_proto_msgTypes[150] + mi := &file_openshell_proto_msgTypes[148] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10994,7 +10730,7 @@ func (x *SubmitPolicyAnalysisRequest) String() string { func (*SubmitPolicyAnalysisRequest) ProtoMessage() {} func (x *SubmitPolicyAnalysisRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[150] + mi := &file_openshell_proto_msgTypes[148] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11007,7 +10743,7 @@ func (x *SubmitPolicyAnalysisRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SubmitPolicyAnalysisRequest.ProtoReflect.Descriptor instead. func (*SubmitPolicyAnalysisRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{150} + return file_openshell_proto_rawDescGZIP(), []int{148} } func (x *SubmitPolicyAnalysisRequest) GetSummaries() []*DenialSummary { @@ -11070,7 +10806,7 @@ type SubmitPolicyAnalysisResponse struct { func (x *SubmitPolicyAnalysisResponse) Reset() { *x = SubmitPolicyAnalysisResponse{} - mi := &file_openshell_proto_msgTypes[151] + mi := &file_openshell_proto_msgTypes[149] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11082,7 +10818,7 @@ func (x *SubmitPolicyAnalysisResponse) String() string { func (*SubmitPolicyAnalysisResponse) ProtoMessage() {} func (x *SubmitPolicyAnalysisResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[151] + mi := &file_openshell_proto_msgTypes[149] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11095,7 +10831,7 @@ func (x *SubmitPolicyAnalysisResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SubmitPolicyAnalysisResponse.ProtoReflect.Descriptor instead. func (*SubmitPolicyAnalysisResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{151} + return file_openshell_proto_rawDescGZIP(), []int{149} } func (x *SubmitPolicyAnalysisResponse) GetAcceptedChunks() uint32 { @@ -11141,7 +10877,7 @@ type GetDraftPolicyRequest struct { func (x *GetDraftPolicyRequest) Reset() { *x = GetDraftPolicyRequest{} - mi := &file_openshell_proto_msgTypes[152] + mi := &file_openshell_proto_msgTypes[150] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11153,7 +10889,7 @@ func (x *GetDraftPolicyRequest) String() string { func (*GetDraftPolicyRequest) ProtoMessage() {} func (x *GetDraftPolicyRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[152] + mi := &file_openshell_proto_msgTypes[150] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11166,7 +10902,7 @@ func (x *GetDraftPolicyRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftPolicyRequest.ProtoReflect.Descriptor instead. func (*GetDraftPolicyRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{152} + return file_openshell_proto_rawDescGZIP(), []int{150} } func (x *GetDraftPolicyRequest) GetName() string { @@ -11206,7 +10942,7 @@ type GetDraftPolicyResponse struct { func (x *GetDraftPolicyResponse) Reset() { *x = GetDraftPolicyResponse{} - mi := &file_openshell_proto_msgTypes[153] + mi := &file_openshell_proto_msgTypes[151] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11218,7 +10954,7 @@ func (x *GetDraftPolicyResponse) String() string { func (*GetDraftPolicyResponse) ProtoMessage() {} func (x *GetDraftPolicyResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[153] + mi := &file_openshell_proto_msgTypes[151] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11231,7 +10967,7 @@ func (x *GetDraftPolicyResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftPolicyResponse.ProtoReflect.Descriptor instead. func (*GetDraftPolicyResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{153} + return file_openshell_proto_rawDescGZIP(), []int{151} } func (x *GetDraftPolicyResponse) GetChunks() []*PolicyChunk { @@ -11277,7 +11013,7 @@ type ApproveDraftChunkRequest struct { func (x *ApproveDraftChunkRequest) Reset() { *x = ApproveDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[154] + mi := &file_openshell_proto_msgTypes[152] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11289,7 +11025,7 @@ func (x *ApproveDraftChunkRequest) String() string { func (*ApproveDraftChunkRequest) ProtoMessage() {} func (x *ApproveDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[154] + mi := &file_openshell_proto_msgTypes[152] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11302,7 +11038,7 @@ func (x *ApproveDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveDraftChunkRequest.ProtoReflect.Descriptor instead. func (*ApproveDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{154} + return file_openshell_proto_rawDescGZIP(), []int{152} } func (x *ApproveDraftChunkRequest) GetName() string { @@ -11338,7 +11074,7 @@ type ApproveDraftChunkResponse struct { func (x *ApproveDraftChunkResponse) Reset() { *x = ApproveDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[155] + mi := &file_openshell_proto_msgTypes[153] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11350,7 +11086,7 @@ func (x *ApproveDraftChunkResponse) String() string { func (*ApproveDraftChunkResponse) ProtoMessage() {} func (x *ApproveDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[155] + mi := &file_openshell_proto_msgTypes[153] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11363,7 +11099,7 @@ func (x *ApproveDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveDraftChunkResponse.ProtoReflect.Descriptor instead. func (*ApproveDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{155} + return file_openshell_proto_rawDescGZIP(), []int{153} } func (x *ApproveDraftChunkResponse) GetPolicyVersion() uint32 { @@ -11397,7 +11133,7 @@ type RejectDraftChunkRequest struct { func (x *RejectDraftChunkRequest) Reset() { *x = RejectDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[156] + mi := &file_openshell_proto_msgTypes[154] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11409,7 +11145,7 @@ func (x *RejectDraftChunkRequest) String() string { func (*RejectDraftChunkRequest) ProtoMessage() {} func (x *RejectDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[156] + mi := &file_openshell_proto_msgTypes[154] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11422,7 +11158,7 @@ func (x *RejectDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RejectDraftChunkRequest.ProtoReflect.Descriptor instead. func (*RejectDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{156} + return file_openshell_proto_rawDescGZIP(), []int{154} } func (x *RejectDraftChunkRequest) GetName() string { @@ -11461,7 +11197,7 @@ type RejectDraftChunkResponse struct { func (x *RejectDraftChunkResponse) Reset() { *x = RejectDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[157] + mi := &file_openshell_proto_msgTypes[155] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11473,7 +11209,7 @@ func (x *RejectDraftChunkResponse) String() string { func (*RejectDraftChunkResponse) ProtoMessage() {} func (x *RejectDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[157] + mi := &file_openshell_proto_msgTypes[155] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11486,7 +11222,7 @@ func (x *RejectDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RejectDraftChunkResponse.ProtoReflect.Descriptor instead. func (*RejectDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{157} + return file_openshell_proto_rawDescGZIP(), []int{155} } // Approve all pending chunks. @@ -11504,7 +11240,7 @@ type ApproveAllDraftChunksRequest struct { func (x *ApproveAllDraftChunksRequest) Reset() { *x = ApproveAllDraftChunksRequest{} - mi := &file_openshell_proto_msgTypes[158] + mi := &file_openshell_proto_msgTypes[156] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11516,7 +11252,7 @@ func (x *ApproveAllDraftChunksRequest) String() string { func (*ApproveAllDraftChunksRequest) ProtoMessage() {} func (x *ApproveAllDraftChunksRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[158] + mi := &file_openshell_proto_msgTypes[156] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11529,7 +11265,7 @@ func (x *ApproveAllDraftChunksRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveAllDraftChunksRequest.ProtoReflect.Descriptor instead. func (*ApproveAllDraftChunksRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{158} + return file_openshell_proto_rawDescGZIP(), []int{156} } func (x *ApproveAllDraftChunksRequest) GetName() string { @@ -11569,7 +11305,7 @@ type ApproveAllDraftChunksResponse struct { func (x *ApproveAllDraftChunksResponse) Reset() { *x = ApproveAllDraftChunksResponse{} - mi := &file_openshell_proto_msgTypes[159] + mi := &file_openshell_proto_msgTypes[157] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11581,7 +11317,7 @@ func (x *ApproveAllDraftChunksResponse) String() string { func (*ApproveAllDraftChunksResponse) ProtoMessage() {} func (x *ApproveAllDraftChunksResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[159] + mi := &file_openshell_proto_msgTypes[157] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11594,7 +11330,7 @@ func (x *ApproveAllDraftChunksResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ApproveAllDraftChunksResponse.ProtoReflect.Descriptor instead. func (*ApproveAllDraftChunksResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{159} + return file_openshell_proto_rawDescGZIP(), []int{157} } func (x *ApproveAllDraftChunksResponse) GetPolicyVersion() uint32 { @@ -11642,7 +11378,7 @@ type EditDraftChunkRequest struct { func (x *EditDraftChunkRequest) Reset() { *x = EditDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[160] + mi := &file_openshell_proto_msgTypes[158] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11654,7 +11390,7 @@ func (x *EditDraftChunkRequest) String() string { func (*EditDraftChunkRequest) ProtoMessage() {} func (x *EditDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[160] + mi := &file_openshell_proto_msgTypes[158] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11667,7 +11403,7 @@ func (x *EditDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use EditDraftChunkRequest.ProtoReflect.Descriptor instead. func (*EditDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{160} + return file_openshell_proto_rawDescGZIP(), []int{158} } func (x *EditDraftChunkRequest) GetName() string { @@ -11706,7 +11442,7 @@ type EditDraftChunkResponse struct { func (x *EditDraftChunkResponse) Reset() { *x = EditDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[161] + mi := &file_openshell_proto_msgTypes[159] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11718,7 +11454,7 @@ func (x *EditDraftChunkResponse) String() string { func (*EditDraftChunkResponse) ProtoMessage() {} func (x *EditDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[161] + mi := &file_openshell_proto_msgTypes[159] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11731,7 +11467,7 @@ func (x *EditDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use EditDraftChunkResponse.ProtoReflect.Descriptor instead. func (*EditDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{161} + return file_openshell_proto_rawDescGZIP(), []int{159} } // Reverse an approval (remove merged rule from active policy). @@ -11749,7 +11485,7 @@ type UndoDraftChunkRequest struct { func (x *UndoDraftChunkRequest) Reset() { *x = UndoDraftChunkRequest{} - mi := &file_openshell_proto_msgTypes[162] + mi := &file_openshell_proto_msgTypes[160] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11761,7 +11497,7 @@ func (x *UndoDraftChunkRequest) String() string { func (*UndoDraftChunkRequest) ProtoMessage() {} func (x *UndoDraftChunkRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[162] + mi := &file_openshell_proto_msgTypes[160] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11774,7 +11510,7 @@ func (x *UndoDraftChunkRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UndoDraftChunkRequest.ProtoReflect.Descriptor instead. func (*UndoDraftChunkRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{162} + return file_openshell_proto_rawDescGZIP(), []int{160} } func (x *UndoDraftChunkRequest) GetName() string { @@ -11810,7 +11546,7 @@ type UndoDraftChunkResponse struct { func (x *UndoDraftChunkResponse) Reset() { *x = UndoDraftChunkResponse{} - mi := &file_openshell_proto_msgTypes[163] + mi := &file_openshell_proto_msgTypes[161] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11822,7 +11558,7 @@ func (x *UndoDraftChunkResponse) String() string { func (*UndoDraftChunkResponse) ProtoMessage() {} func (x *UndoDraftChunkResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[163] + mi := &file_openshell_proto_msgTypes[161] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11835,7 +11571,7 @@ func (x *UndoDraftChunkResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UndoDraftChunkResponse.ProtoReflect.Descriptor instead. func (*UndoDraftChunkResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{163} + return file_openshell_proto_rawDescGZIP(), []int{161} } func (x *UndoDraftChunkResponse) GetPolicyVersion() uint32 { @@ -11865,7 +11601,7 @@ type ClearDraftChunksRequest struct { func (x *ClearDraftChunksRequest) Reset() { *x = ClearDraftChunksRequest{} - mi := &file_openshell_proto_msgTypes[164] + mi := &file_openshell_proto_msgTypes[162] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11877,7 +11613,7 @@ func (x *ClearDraftChunksRequest) String() string { func (*ClearDraftChunksRequest) ProtoMessage() {} func (x *ClearDraftChunksRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[164] + mi := &file_openshell_proto_msgTypes[162] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11890,7 +11626,7 @@ func (x *ClearDraftChunksRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ClearDraftChunksRequest.ProtoReflect.Descriptor instead. func (*ClearDraftChunksRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{164} + return file_openshell_proto_rawDescGZIP(), []int{162} } func (x *ClearDraftChunksRequest) GetName() string { @@ -11917,7 +11653,7 @@ type ClearDraftChunksResponse struct { func (x *ClearDraftChunksResponse) Reset() { *x = ClearDraftChunksResponse{} - mi := &file_openshell_proto_msgTypes[165] + mi := &file_openshell_proto_msgTypes[163] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11929,7 +11665,7 @@ func (x *ClearDraftChunksResponse) String() string { func (*ClearDraftChunksResponse) ProtoMessage() {} func (x *ClearDraftChunksResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[165] + mi := &file_openshell_proto_msgTypes[163] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11942,7 +11678,7 @@ func (x *ClearDraftChunksResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ClearDraftChunksResponse.ProtoReflect.Descriptor instead. func (*ClearDraftChunksResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{165} + return file_openshell_proto_rawDescGZIP(), []int{163} } func (x *ClearDraftChunksResponse) GetChunksCleared() uint32 { @@ -11965,7 +11701,7 @@ type GetDraftHistoryRequest struct { func (x *GetDraftHistoryRequest) Reset() { *x = GetDraftHistoryRequest{} - mi := &file_openshell_proto_msgTypes[166] + mi := &file_openshell_proto_msgTypes[164] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11977,7 +11713,7 @@ func (x *GetDraftHistoryRequest) String() string { func (*GetDraftHistoryRequest) ProtoMessage() {} func (x *GetDraftHistoryRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[166] + mi := &file_openshell_proto_msgTypes[164] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11990,7 +11726,7 @@ func (x *GetDraftHistoryRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftHistoryRequest.ProtoReflect.Descriptor instead. func (*GetDraftHistoryRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{166} + return file_openshell_proto_rawDescGZIP(), []int{164} } func (x *GetDraftHistoryRequest) GetName() string { @@ -12024,7 +11760,7 @@ type DraftHistoryEntry struct { func (x *DraftHistoryEntry) Reset() { *x = DraftHistoryEntry{} - mi := &file_openshell_proto_msgTypes[167] + mi := &file_openshell_proto_msgTypes[165] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12036,7 +11772,7 @@ func (x *DraftHistoryEntry) String() string { func (*DraftHistoryEntry) ProtoMessage() {} func (x *DraftHistoryEntry) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[167] + mi := &file_openshell_proto_msgTypes[165] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12049,7 +11785,7 @@ func (x *DraftHistoryEntry) ProtoReflect() protoreflect.Message { // Deprecated: Use DraftHistoryEntry.ProtoReflect.Descriptor instead. func (*DraftHistoryEntry) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{167} + return file_openshell_proto_rawDescGZIP(), []int{165} } func (x *DraftHistoryEntry) GetTimestampMs() int64 { @@ -12090,7 +11826,7 @@ type GetDraftHistoryResponse struct { func (x *GetDraftHistoryResponse) Reset() { *x = GetDraftHistoryResponse{} - mi := &file_openshell_proto_msgTypes[168] + mi := &file_openshell_proto_msgTypes[166] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12102,7 +11838,7 @@ func (x *GetDraftHistoryResponse) String() string { func (*GetDraftHistoryResponse) ProtoMessage() {} func (x *GetDraftHistoryResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[168] + mi := &file_openshell_proto_msgTypes[166] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12115,7 +11851,7 @@ func (x *GetDraftHistoryResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDraftHistoryResponse.ProtoReflect.Descriptor instead. func (*GetDraftHistoryResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{168} + return file_openshell_proto_rawDescGZIP(), []int{166} } func (x *GetDraftHistoryResponse) GetEntries() []*DraftHistoryEntry { @@ -12144,7 +11880,7 @@ type PolicyRevisionPayload struct { func (x *PolicyRevisionPayload) Reset() { *x = PolicyRevisionPayload{} - mi := &file_openshell_proto_msgTypes[169] + mi := &file_openshell_proto_msgTypes[167] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12156,7 +11892,7 @@ func (x *PolicyRevisionPayload) String() string { func (*PolicyRevisionPayload) ProtoMessage() {} func (x *PolicyRevisionPayload) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[169] + mi := &file_openshell_proto_msgTypes[167] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12169,7 +11905,7 @@ func (x *PolicyRevisionPayload) ProtoReflect() protoreflect.Message { // Deprecated: Use PolicyRevisionPayload.ProtoReflect.Descriptor instead. func (*PolicyRevisionPayload) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{169} + return file_openshell_proto_rawDescGZIP(), []int{167} } func (x *PolicyRevisionPayload) GetPolicy() *sandboxv1.SandboxPolicy { @@ -12242,7 +11978,7 @@ type DraftChunkPayload struct { func (x *DraftChunkPayload) Reset() { *x = DraftChunkPayload{} - mi := &file_openshell_proto_msgTypes[170] + mi := &file_openshell_proto_msgTypes[168] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12254,7 +11990,7 @@ func (x *DraftChunkPayload) String() string { func (*DraftChunkPayload) ProtoMessage() {} func (x *DraftChunkPayload) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[170] + mi := &file_openshell_proto_msgTypes[168] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12267,7 +12003,7 @@ func (x *DraftChunkPayload) ProtoReflect() protoreflect.Message { // Deprecated: Use DraftChunkPayload.ProtoReflect.Descriptor instead. func (*DraftChunkPayload) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{170} + return file_openshell_proto_rawDescGZIP(), []int{168} } func (x *DraftChunkPayload) GetRuleName() string { @@ -12373,7 +12109,7 @@ type StoredPolicyRevision struct { func (x *StoredPolicyRevision) Reset() { *x = StoredPolicyRevision{} - mi := &file_openshell_proto_msgTypes[171] + mi := &file_openshell_proto_msgTypes[169] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12385,7 +12121,7 @@ func (x *StoredPolicyRevision) String() string { func (*StoredPolicyRevision) ProtoMessage() {} func (x *StoredPolicyRevision) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[171] + mi := &file_openshell_proto_msgTypes[169] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12398,7 +12134,7 @@ func (x *StoredPolicyRevision) ProtoReflect() protoreflect.Message { // Deprecated: Use StoredPolicyRevision.ProtoReflect.Descriptor instead. func (*StoredPolicyRevision) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{171} + return file_openshell_proto_rawDescGZIP(), []int{169} } func (x *StoredPolicyRevision) GetId() string { @@ -12501,7 +12237,7 @@ type StoredDraftChunk struct { func (x *StoredDraftChunk) Reset() { *x = StoredDraftChunk{} - mi := &file_openshell_proto_msgTypes[172] + mi := &file_openshell_proto_msgTypes[170] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12513,7 +12249,7 @@ func (x *StoredDraftChunk) String() string { func (*StoredDraftChunk) ProtoMessage() {} func (x *StoredDraftChunk) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[172] + mi := &file_openshell_proto_msgTypes[170] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12526,7 +12262,7 @@ func (x *StoredDraftChunk) ProtoReflect() protoreflect.Message { // Deprecated: Use StoredDraftChunk.ProtoReflect.Descriptor instead. func (*StoredDraftChunk) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{172} + return file_openshell_proto_rawDescGZIP(), []int{170} } func (x *StoredDraftChunk) GetId() string { @@ -12675,7 +12411,7 @@ type CreateWorkspaceRequest struct { func (x *CreateWorkspaceRequest) Reset() { *x = CreateWorkspaceRequest{} - mi := &file_openshell_proto_msgTypes[173] + mi := &file_openshell_proto_msgTypes[171] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12687,7 +12423,7 @@ func (x *CreateWorkspaceRequest) String() string { func (*CreateWorkspaceRequest) ProtoMessage() {} func (x *CreateWorkspaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[173] + mi := &file_openshell_proto_msgTypes[171] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12700,7 +12436,7 @@ func (x *CreateWorkspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateWorkspaceRequest.ProtoReflect.Descriptor instead. func (*CreateWorkspaceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{173} + return file_openshell_proto_rawDescGZIP(), []int{171} } func (x *CreateWorkspaceRequest) GetName() string { @@ -12727,7 +12463,7 @@ type CreateWorkspaceResponse struct { func (x *CreateWorkspaceResponse) Reset() { *x = CreateWorkspaceResponse{} - mi := &file_openshell_proto_msgTypes[174] + mi := &file_openshell_proto_msgTypes[172] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12739,7 +12475,7 @@ func (x *CreateWorkspaceResponse) String() string { func (*CreateWorkspaceResponse) ProtoMessage() {} func (x *CreateWorkspaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[174] + mi := &file_openshell_proto_msgTypes[172] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12752,7 +12488,7 @@ func (x *CreateWorkspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateWorkspaceResponse.ProtoReflect.Descriptor instead. func (*CreateWorkspaceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{174} + return file_openshell_proto_rawDescGZIP(), []int{172} } func (x *CreateWorkspaceResponse) GetWorkspace() *datamodelv1.Workspace { @@ -12773,7 +12509,7 @@ type GetWorkspaceRequest struct { func (x *GetWorkspaceRequest) Reset() { *x = GetWorkspaceRequest{} - mi := &file_openshell_proto_msgTypes[175] + mi := &file_openshell_proto_msgTypes[173] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12785,7 +12521,7 @@ func (x *GetWorkspaceRequest) String() string { func (*GetWorkspaceRequest) ProtoMessage() {} func (x *GetWorkspaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[175] + mi := &file_openshell_proto_msgTypes[173] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12798,7 +12534,7 @@ func (x *GetWorkspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetWorkspaceRequest.ProtoReflect.Descriptor instead. func (*GetWorkspaceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{175} + return file_openshell_proto_rawDescGZIP(), []int{173} } func (x *GetWorkspaceRequest) GetName() string { @@ -12818,7 +12554,7 @@ type GetWorkspaceResponse struct { func (x *GetWorkspaceResponse) Reset() { *x = GetWorkspaceResponse{} - mi := &file_openshell_proto_msgTypes[176] + mi := &file_openshell_proto_msgTypes[174] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12830,7 +12566,7 @@ func (x *GetWorkspaceResponse) String() string { func (*GetWorkspaceResponse) ProtoMessage() {} func (x *GetWorkspaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[176] + mi := &file_openshell_proto_msgTypes[174] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12843,7 +12579,7 @@ func (x *GetWorkspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetWorkspaceResponse.ProtoReflect.Descriptor instead. func (*GetWorkspaceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{176} + return file_openshell_proto_rawDescGZIP(), []int{174} } func (x *GetWorkspaceResponse) GetWorkspace() *datamodelv1.Workspace { @@ -12866,7 +12602,7 @@ type ListWorkspacesRequest struct { func (x *ListWorkspacesRequest) Reset() { *x = ListWorkspacesRequest{} - mi := &file_openshell_proto_msgTypes[177] + mi := &file_openshell_proto_msgTypes[175] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12878,7 +12614,7 @@ func (x *ListWorkspacesRequest) String() string { func (*ListWorkspacesRequest) ProtoMessage() {} func (x *ListWorkspacesRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[177] + mi := &file_openshell_proto_msgTypes[175] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12891,7 +12627,7 @@ func (x *ListWorkspacesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspacesRequest.ProtoReflect.Descriptor instead. func (*ListWorkspacesRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{177} + return file_openshell_proto_rawDescGZIP(), []int{175} } func (x *ListWorkspacesRequest) GetLimit() uint32 { @@ -12925,7 +12661,7 @@ type ListWorkspacesResponse struct { func (x *ListWorkspacesResponse) Reset() { *x = ListWorkspacesResponse{} - mi := &file_openshell_proto_msgTypes[178] + mi := &file_openshell_proto_msgTypes[176] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12937,7 +12673,7 @@ func (x *ListWorkspacesResponse) String() string { func (*ListWorkspacesResponse) ProtoMessage() {} func (x *ListWorkspacesResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[178] + mi := &file_openshell_proto_msgTypes[176] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12950,7 +12686,7 @@ func (x *ListWorkspacesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspacesResponse.ProtoReflect.Descriptor instead. func (*ListWorkspacesResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{178} + return file_openshell_proto_rawDescGZIP(), []int{176} } func (x *ListWorkspacesResponse) GetWorkspaces() []*datamodelv1.Workspace { @@ -12971,7 +12707,7 @@ type DeleteWorkspaceRequest struct { func (x *DeleteWorkspaceRequest) Reset() { *x = DeleteWorkspaceRequest{} - mi := &file_openshell_proto_msgTypes[179] + mi := &file_openshell_proto_msgTypes[177] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -12983,7 +12719,7 @@ func (x *DeleteWorkspaceRequest) String() string { func (*DeleteWorkspaceRequest) ProtoMessage() {} func (x *DeleteWorkspaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[179] + mi := &file_openshell_proto_msgTypes[177] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -12996,7 +12732,7 @@ func (x *DeleteWorkspaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteWorkspaceRequest.ProtoReflect.Descriptor instead. func (*DeleteWorkspaceRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{179} + return file_openshell_proto_rawDescGZIP(), []int{177} } func (x *DeleteWorkspaceRequest) GetName() string { @@ -13016,7 +12752,7 @@ type DeleteWorkspaceResponse struct { func (x *DeleteWorkspaceResponse) Reset() { *x = DeleteWorkspaceResponse{} - mi := &file_openshell_proto_msgTypes[180] + mi := &file_openshell_proto_msgTypes[178] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13028,7 +12764,7 @@ func (x *DeleteWorkspaceResponse) String() string { func (*DeleteWorkspaceResponse) ProtoMessage() {} func (x *DeleteWorkspaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[180] + mi := &file_openshell_proto_msgTypes[178] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13041,7 +12777,7 @@ func (x *DeleteWorkspaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteWorkspaceResponse.ProtoReflect.Descriptor instead. func (*DeleteWorkspaceResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{180} + return file_openshell_proto_rawDescGZIP(), []int{178} } func (x *DeleteWorkspaceResponse) GetDeleted() bool { @@ -13065,7 +12801,7 @@ type WorkspaceMember struct { func (x *WorkspaceMember) Reset() { *x = WorkspaceMember{} - mi := &file_openshell_proto_msgTypes[181] + mi := &file_openshell_proto_msgTypes[179] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13077,7 +12813,7 @@ func (x *WorkspaceMember) String() string { func (*WorkspaceMember) ProtoMessage() {} func (x *WorkspaceMember) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[181] + mi := &file_openshell_proto_msgTypes[179] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13090,7 +12826,7 @@ func (x *WorkspaceMember) ProtoReflect() protoreflect.Message { // Deprecated: Use WorkspaceMember.ProtoReflect.Descriptor instead. func (*WorkspaceMember) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{181} + return file_openshell_proto_rawDescGZIP(), []int{179} } func (x *WorkspaceMember) GetMetadata() *datamodelv1.ObjectMeta { @@ -13129,7 +12865,7 @@ type AddWorkspaceMemberRequest struct { func (x *AddWorkspaceMemberRequest) Reset() { *x = AddWorkspaceMemberRequest{} - mi := &file_openshell_proto_msgTypes[182] + mi := &file_openshell_proto_msgTypes[180] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13141,7 +12877,7 @@ func (x *AddWorkspaceMemberRequest) String() string { func (*AddWorkspaceMemberRequest) ProtoMessage() {} func (x *AddWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[182] + mi := &file_openshell_proto_msgTypes[180] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13154,7 +12890,7 @@ func (x *AddWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use AddWorkspaceMemberRequest.ProtoReflect.Descriptor instead. func (*AddWorkspaceMemberRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{182} + return file_openshell_proto_rawDescGZIP(), []int{180} } func (x *AddWorkspaceMemberRequest) GetWorkspace() string { @@ -13188,7 +12924,7 @@ type AddWorkspaceMemberResponse struct { func (x *AddWorkspaceMemberResponse) Reset() { *x = AddWorkspaceMemberResponse{} - mi := &file_openshell_proto_msgTypes[183] + mi := &file_openshell_proto_msgTypes[181] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13200,7 +12936,7 @@ func (x *AddWorkspaceMemberResponse) String() string { func (*AddWorkspaceMemberResponse) ProtoMessage() {} func (x *AddWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[183] + mi := &file_openshell_proto_msgTypes[181] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13213,7 +12949,7 @@ func (x *AddWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use AddWorkspaceMemberResponse.ProtoReflect.Descriptor instead. func (*AddWorkspaceMemberResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{183} + return file_openshell_proto_rawDescGZIP(), []int{181} } func (x *AddWorkspaceMemberResponse) GetMember() *WorkspaceMember { @@ -13236,7 +12972,7 @@ type RemoveWorkspaceMemberRequest struct { func (x *RemoveWorkspaceMemberRequest) Reset() { *x = RemoveWorkspaceMemberRequest{} - mi := &file_openshell_proto_msgTypes[184] + mi := &file_openshell_proto_msgTypes[182] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13248,7 +12984,7 @@ func (x *RemoveWorkspaceMemberRequest) String() string { func (*RemoveWorkspaceMemberRequest) ProtoMessage() {} func (x *RemoveWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[184] + mi := &file_openshell_proto_msgTypes[182] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13261,7 +12997,7 @@ func (x *RemoveWorkspaceMemberRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveWorkspaceMemberRequest.ProtoReflect.Descriptor instead. func (*RemoveWorkspaceMemberRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{184} + return file_openshell_proto_rawDescGZIP(), []int{182} } func (x *RemoveWorkspaceMemberRequest) GetWorkspace() string { @@ -13288,7 +13024,7 @@ type RemoveWorkspaceMemberResponse struct { func (x *RemoveWorkspaceMemberResponse) Reset() { *x = RemoveWorkspaceMemberResponse{} - mi := &file_openshell_proto_msgTypes[185] + mi := &file_openshell_proto_msgTypes[183] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13300,7 +13036,7 @@ func (x *RemoveWorkspaceMemberResponse) String() string { func (*RemoveWorkspaceMemberResponse) ProtoMessage() {} func (x *RemoveWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[185] + mi := &file_openshell_proto_msgTypes[183] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13313,7 +13049,7 @@ func (x *RemoveWorkspaceMemberResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveWorkspaceMemberResponse.ProtoReflect.Descriptor instead. func (*RemoveWorkspaceMemberResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{185} + return file_openshell_proto_rawDescGZIP(), []int{183} } func (x *RemoveWorkspaceMemberResponse) GetRemoved() bool { @@ -13336,7 +13072,7 @@ type ListWorkspaceMembersRequest struct { func (x *ListWorkspaceMembersRequest) Reset() { *x = ListWorkspaceMembersRequest{} - mi := &file_openshell_proto_msgTypes[186] + mi := &file_openshell_proto_msgTypes[184] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13348,7 +13084,7 @@ func (x *ListWorkspaceMembersRequest) String() string { func (*ListWorkspaceMembersRequest) ProtoMessage() {} func (x *ListWorkspaceMembersRequest) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[186] + mi := &file_openshell_proto_msgTypes[184] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13361,7 +13097,7 @@ func (x *ListWorkspaceMembersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspaceMembersRequest.ProtoReflect.Descriptor instead. func (*ListWorkspaceMembersRequest) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{186} + return file_openshell_proto_rawDescGZIP(), []int{184} } func (x *ListWorkspaceMembersRequest) GetWorkspace() string { @@ -13395,7 +13131,7 @@ type ListWorkspaceMembersResponse struct { func (x *ListWorkspaceMembersResponse) Reset() { *x = ListWorkspaceMembersResponse{} - mi := &file_openshell_proto_msgTypes[187] + mi := &file_openshell_proto_msgTypes[185] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13407,7 +13143,7 @@ func (x *ListWorkspaceMembersResponse) String() string { func (*ListWorkspaceMembersResponse) ProtoMessage() {} func (x *ListWorkspaceMembersResponse) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[187] + mi := &file_openshell_proto_msgTypes[185] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13420,7 +13156,7 @@ func (x *ListWorkspaceMembersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkspaceMembersResponse.ProtoReflect.Descriptor instead. func (*ListWorkspaceMembersResponse) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{187} + return file_openshell_proto_rawDescGZIP(), []int{185} } func (x *ListWorkspaceMembersResponse) GetMembers() []*WorkspaceMember { @@ -13448,7 +13184,7 @@ type ExtensionServiceCredential struct { func (x *ExtensionServiceCredential) Reset() { *x = ExtensionServiceCredential{} - mi := &file_openshell_proto_msgTypes[188] + mi := &file_openshell_proto_msgTypes[186] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -13460,7 +13196,7 @@ func (x *ExtensionServiceCredential) String() string { func (*ExtensionServiceCredential) ProtoMessage() {} func (x *ExtensionServiceCredential) ProtoReflect() protoreflect.Message { - mi := &file_openshell_proto_msgTypes[188] + mi := &file_openshell_proto_msgTypes[186] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -13473,7 +13209,7 @@ func (x *ExtensionServiceCredential) ProtoReflect() protoreflect.Message { // Deprecated: Use ExtensionServiceCredential.ProtoReflect.Descriptor instead. func (*ExtensionServiceCredential) Descriptor() ([]byte, []int) { - return file_openshell_proto_rawDescGZIP(), []int{188} + return file_openshell_proto_rawDescGZIP(), []int{186} } func (x *ExtensionServiceCredential) GetServiceName() string { @@ -13530,37 +13266,29 @@ const file_openshell_proto_rawDesc = "" + "\x0fcompute_drivers\x18\x03 \x03(\v2\x1f.openshell.v1.ComputeDriverInfoR\x0ecomputeDrivers\"t\n" + "\x11ComputeDriverInfo\x12\x12\n" + "\x04name\x18\x01 \x01(\tR\x04name\x12K\n" + - "\fcapabilities\x18\x02 \x01(\v2'.openshell.v1.ComputeDriverCapabilitiesR\fcapabilities\"\x97\x01\n" + + "\fcapabilities\x18\x02 \x01(\v2'.openshell.v1.ComputeDriverCapabilitiesR\fcapabilities\"c\n" + "\x19ComputeDriverCapabilities\x12\x1f\n" + "\vdriver_name\x18\x01 \x01(\tR\n" + "driverName\x12%\n" + - "\x0edriver_version\x18\x02 \x01(\tR\rdriverVersion\x122\n" + - "\x15supports_main_process\x18\x03 \x01(\bR\x13supportsMainProcess\"\xd8\x01\n" + + "\x0edriver_version\x18\x02 \x01(\tR\rdriverVersion\"\xd8\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\"\x99\x04\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" + "\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" + "\btemplate\x18\x06 \x01(\v2\x1d.openshell.v1.SandboxTemplateR\btemplate\x12;\n" + "\x06policy\x18\a \x01(\v2#.openshell.sandbox.v1.SandboxPolicyR\x06policy\x12\x1c\n" + "\tproviders\x18\b \x03(\tR\tproviders\x12W\n" + - "\x15resource_requirements\x18\t \x01(\v2\".openshell.v1.ResourceRequirementsR\x14resourceRequirements\x12@\n" + - "\fmain_process\x18\f \x01(\v2\x1d.openshell.v1.MainProcessSpecR\vmainProcess\x1a>\n" + + "\x15resource_requirements\x18\t \x01(\v2\".openshell.v1.ResourceRequirementsR\x14resourceRequirements\x12\x18\n" + + "\acommand\x18\f \x03(\tR\acommand\x12\x10\n" + + "\x03tty\x18\r \x01(\bR\x03tty\x1a>\n" + "\x10EnvironmentEntry\x12\x10\n" + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01J\x04\b\n" + "\x10\vJ\x04\b\v\x10\fR\n" + - "gpu_deviceR\x16proposal_approval_mode\"\x86\x02\n" + - "\x0fMainProcessSpec\x12\x18\n" + - "\acommand\x18\x01 \x03(\tR\acommand\x12P\n" + - "\venvironment\x18\x02 \x03(\v2..openshell.v1.MainProcessSpec.EnvironmentEntryR\venvironment\x12+\n" + - "\x11working_directory\x18\x03 \x01(\tR\x10workingDirectory\x12\x1a\n" + - "\bterminal\x18\x04 \x01(\bR\bterminal\x1a>\n" + - "\x10EnvironmentEntry\x12\x10\n" + - "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + - "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"O\n" + + "gpu_deviceR\x16proposal_approval_mode\"O\n" + "\x14ResourceRequirements\x127\n" + "\x03gpu\x18\x01 \x01(\v2%.openshell.v1.GpuResourceRequirementsR\x03gpu\">\n" + "\x17GpuResourceRequirements\x12\x19\n" + @@ -13587,7 +13315,7 @@ const file_openshell_proto_rawDesc = "" + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01B\x12\n" + "\x10_user_namespacesJ\x04\b\t\x10\n" + - "R\x16volume_claim_templates\"\xf5\x02\n" + + "R\x16volume_claim_templates\"\x9a\x03\n" + "\rSandboxStatus\x12!\n" + "\fsandbox_name\x18\x01 \x01(\tR\vsandboxName\x12\x1b\n" + "\tagent_pod\x18\x02 \x01(\tR\bagentPod\x12\x19\n" + @@ -13598,20 +13326,11 @@ const file_openshell_proto_rawDesc = "" + "conditions\x18\x05 \x03(\v2\x1e.openshell.v1.SandboxConditionR\n" + "conditions\x120\n" + "\x05phase\x18\x06 \x01(\x0e2\x1a.openshell.v1.SandboxPhaseR\x05phase\x124\n" + - "\x16current_policy_version\x18\a \x01(\rR\x14currentPolicyVersion\x12B\n" + - "\fmain_process\x18\b \x01(\v2\x1f.openshell.v1.MainProcessStatusR\vmainProcess\"\x8b\x02\n" + - "\x11MainProcessStatus\x124\n" + - "\x05state\x18\x01 \x01(\x0e2\x1e.openshell.v1.MainProcessStateR\x05state\x12\x1e\n" + - "\n" + - "generation\x18\x02 \x01(\tR\n" + - "generation\x12 \n" + - "\texit_code\x18\x03 \x01(\x05H\x00R\bexitCode\x88\x01\x01\x12\x1b\n" + - "\x06signal\x18\x04 \x01(\x05H\x01R\x06signal\x88\x01\x01\x12\"\n" + - "\rstarted_at_ms\x18\x05 \x01(\x03R\vstartedAtMs\x12$\n" + - "\x0efinished_at_ms\x18\x06 \x01(\x03R\ffinishedAtMsB\f\n" + + "\x16current_policy_version\x18\a \x01(\rR\x14currentPolicyVersion\x127\n" + + "\x18main_process_instance_id\x18\b \x01(\tR\x15mainProcessInstanceId\x12 \n" + + "\texit_code\x18\t \x01(\x05H\x00R\bexitCode\x88\x01\x01B\f\n" + "\n" + - "_exit_codeB\t\n" + - "\a_signal\"\xa2\x01\n" + + "_exit_code\"\xa2\x01\n" + "\x10SandboxCondition\x12\x12\n" + "\x04type\x18\x01 \x01(\tR\x04type\x12\x16\n" + "\x06status\x18\x02 \x01(\tR\x06status\x12\x16\n" + @@ -14191,15 +13910,14 @@ const file_openshell_proto_rawDesc = "" + "\x17PushSandboxLogsResponse\"m\n" + "\x16GetSandboxLogsResponse\x120\n" + "\x04logs\x18\x01 \x03(\v2\x1c.openshell.v1.SandboxLogLineR\x04logs\x12!\n" + - "\fbuffer_total\x18\x02 \x01(\rR\vbufferTotal\"\xef\x02\n" + + "\fbuffer_total\x18\x02 \x01(\rR\vbufferTotal\"\xa2\x02\n" + "\x11SupervisorMessage\x125\n" + "\x05hello\x18\x01 \x01(\v2\x1d.openshell.v1.SupervisorHelloH\x00R\x05hello\x12A\n" + "\theartbeat\x18\x02 \x01(\v2!.openshell.v1.SupervisorHeartbeatH\x00R\theartbeat\x12K\n" + "\x11relay_open_result\x18\x03 \x01(\v2\x1d.openshell.v1.RelayOpenResultH\x00R\x0frelayOpenResult\x12;\n" + "\vrelay_close\x18\x04 \x01(\v2\x18.openshell.v1.RelayCloseH\x00R\n" + - "relayClose\x12K\n" + - "\x11main_process_exit\x18\x05 \x01(\v2\x1d.openshell.v1.MainProcessExitH\x00R\x0fmainProcessExitB\t\n" + - "\apayload\"\xc1\x03\n" + + "relayCloseB\t\n" + + "\apayload\"\xea\x02\n" + "\x0eGatewayMessage\x12J\n" + "\x10session_accepted\x18\x01 \x01(\v2\x1d.openshell.v1.SessionAcceptedH\x00R\x0fsessionAccepted\x12J\n" + "\x10session_rejected\x18\x02 \x01(\v2\x1d.openshell.v1.SessionRejectedH\x00R\x0fsessionRejected\x12>\n" + @@ -14207,15 +13925,13 @@ const file_openshell_proto_rawDesc = "" + "\n" + "relay_open\x18\x04 \x01(\v2\x17.openshell.v1.RelayOpenH\x00R\trelayOpen\x12;\n" + "\vrelay_close\x18\x05 \x01(\v2\x18.openshell.v1.RelayCloseH\x00R\n" + - "relayClose\x12U\n" + - "\x15main_process_exit_ack\x18\x06 \x01(\v2 .openshell.v1.MainProcessExitAckH\x00R\x12mainProcessExitAckB\t\n" + - "\apayload\"{\n" + + "relayCloseB\t\n" + + "\apayload\"Q\n" + "\x0fSupervisorHello\x12\x1d\n" + "\n" + "sandbox_id\x18\x01 \x01(\tR\tsandboxId\x12\x1f\n" + "\vinstance_id\x18\x02 \x01(\tR\n" + - "instanceId\x12(\n" + - "\x10exit_report_only\x18\x03 \x01(\bR\x0eexitReportOnly\"h\n" + + "instanceId\"h\n" + "\x0fSessionAccepted\x12\x1d\n" + "\n" + "session_id\x18\x01 \x01(\tR\tsessionId\x126\n" + @@ -14223,22 +13939,14 @@ const file_openshell_proto_rawDesc = "" + "\x0fSessionRejected\x12\x16\n" + "\x06reason\x18\x01 \x01(\tR\x06reason\"\x15\n" + "\x13SupervisorHeartbeat\"\x12\n" + - "\x10GatewayHeartbeat\"\xd3\x01\n" + - "\x0fMainProcessExit\x12\x1e\n" + + "\x10GatewayHeartbeat\"{\n" + + "\x1cReportMainProcessExitRequest\x12\x1d\n" + "\n" + - "generation\x18\x01 \x01(\tR\n" + - "generation\x12 \n" + - "\texit_code\x18\x02 \x01(\x05H\x00R\bexitCode\x88\x01\x01\x12\x1b\n" + - "\x06signal\x18\x03 \x01(\x05H\x01R\x06signal\x88\x01\x01\x12\"\n" + - "\rstarted_at_ms\x18\x04 \x01(\x03R\vstartedAtMs\x12$\n" + - "\x0efinished_at_ms\x18\x05 \x01(\x03R\ffinishedAtMsB\f\n" + - "\n" + - "_exit_codeB\t\n" + - "\a_signal\"4\n" + - "\x12MainProcessExitAck\x12\x1e\n" + - "\n" + - "generation\x18\x01 \x01(\tR\n" + - "generation\"\xb7\x01\n" + + "sandbox_id\x18\x01 \x01(\tR\tsandboxId\x12\x1f\n" + + "\vinstance_id\x18\x02 \x01(\tR\n" + + "instanceId\x12\x1b\n" + + "\texit_code\x18\x03 \x01(\x05R\bexitCode\"\x1f\n" + + "\x1dReportMainProcessExitResponse\"\xb7\x01\n" + "\tRelayOpen\x12\x1d\n" + "\n" + "channel_id\x18\x01 \x01(\tR\tchannelId\x120\n" + @@ -14537,11 +14245,7 @@ const file_openshell_proto_rawDesc = "" + "\x1aExtensionServiceCredential\x12!\n" + "\fservice_name\x18\x01 \x01(\tR\vserviceName\x12\x1a\n" + "\x05token\x18\x02 \x01(\tB\x04\x88\xb5\x18\x01R\x05token\x12\"\n" + - "\rexpires_at_ms\x18\x03 \x01(\x03R\vexpiresAtMs*u\n" + - "\x10MainProcessState\x12\"\n" + - "\x1eMAIN_PROCESS_STATE_UNSPECIFIED\x10\x00\x12\x1e\n" + - "\x1aMAIN_PROCESS_STATE_RUNNING\x10\x01\x12\x1d\n" + - "\x19MAIN_PROCESS_STATE_EXITED\x10\x02*\x89\x02\n" + + "\rexpires_at_ms\x18\x03 \x01(\x03R\vexpiresAtMs*\x89\x02\n" + "\fSandboxPhase\x12\x1d\n" + "\x19SANDBOX_PHASE_UNSPECIFIED\x10\x00\x12\x1e\n" + "\x1aSANDBOX_PHASE_PROVISIONING\x10\x01\x12\x17\n" + @@ -14583,7 +14287,7 @@ const file_openshell_proto_rawDesc = "" + "\rWorkspaceRole\x12\x1e\n" + "\x1aWORKSPACE_ROLE_UNSPECIFIED\x10\x00\x12\x17\n" + "\x13WORKSPACE_ROLE_USER\x10\x01\x12\x18\n" + - "\x14WORKSPACE_ROLE_ADMIN\x10\x022\x94D\n" + + "\x14WORKSPACE_ROLE_ADMIN\x10\x022\x95E\n" + "\tOpenShell\x12Z\n" + "\x06Health\x12\x1b.openshell.v1.HealthRequest\x1a\x1c.openshell.v1.HealthResponse\"\x15\x82\xb5\x18\x11\n" + "\x0funauthenticated\x12i\n" + @@ -14679,7 +14383,9 @@ const file_openshell_proto_rawDesc = "" + "\x0fPushSandboxLogs\x12$.openshell.v1.PushSandboxLogsRequest\x1a%.openshell.v1.PushSandboxLogsResponse\"\r\x82\xb5\x18\t\n" + "\asandbox(\x01\x12e\n" + "\x11ConnectSupervisor\x12\x1f.openshell.v1.SupervisorMessage\x1a\x1c.openshell.v1.GatewayMessage\"\r\x82\xb5\x18\t\n" + - "\asandbox(\x010\x01\x12T\n" + + "\asandbox(\x010\x01\x12\x7f\n" + + "\x15ReportMainProcessExit\x12*.openshell.v1.ReportMainProcessExitRequest\x1a+.openshell.v1.ReportMainProcessExitResponse\"\r\x82\xb5\x18\t\n" + + "\asandbox\x12T\n" + "\vRelayStream\x12\x18.openshell.v1.RelayFrame\x1a\x18.openshell.v1.RelayFrame\"\r\x82\xb5\x18\t\n" + "\asandbox(\x010\x01\x12w\n" + "\fWatchSandbox\x12!.openshell.v1.WatchSandboxRequest\x1a .openshell.v1.SandboxStreamEvent\" \x82\xb5\x18\x1c\n" + @@ -14733,541 +14439,533 @@ func file_openshell_proto_rawDescGZIP() []byte { return file_openshell_proto_rawDescData } -var file_openshell_proto_enumTypes = make([]protoimpl.EnumInfo, 7) -var file_openshell_proto_msgTypes = make([]protoimpl.MessageInfo, 214) +var file_openshell_proto_enumTypes = make([]protoimpl.EnumInfo, 6) +var file_openshell_proto_msgTypes = make([]protoimpl.MessageInfo, 211) var file_openshell_proto_goTypes = []any{ - (MainProcessState)(0), // 0: openshell.v1.MainProcessState - (SandboxPhase)(0), // 1: openshell.v1.SandboxPhase - (ProviderCredentialRefreshStrategy)(0), // 2: openshell.v1.ProviderCredentialRefreshStrategy - (ProviderProfileCategory)(0), // 3: openshell.v1.ProviderProfileCategory - (PolicyStatus)(0), // 4: openshell.v1.PolicyStatus - (ServiceStatus)(0), // 5: openshell.v1.ServiceStatus - (WorkspaceRole)(0), // 6: openshell.v1.WorkspaceRole - (*IssueSandboxTokenRequest)(nil), // 7: openshell.v1.IssueSandboxTokenRequest - (*IssueSandboxTokenResponse)(nil), // 8: openshell.v1.IssueSandboxTokenResponse - (*RefreshSandboxTokenRequest)(nil), // 9: openshell.v1.RefreshSandboxTokenRequest - (*RefreshSandboxTokenResponse)(nil), // 10: openshell.v1.RefreshSandboxTokenResponse - (*HealthRequest)(nil), // 11: openshell.v1.HealthRequest - (*HealthResponse)(nil), // 12: openshell.v1.HealthResponse - (*GetCurrentUserRequest)(nil), // 13: openshell.v1.GetCurrentUserRequest - (*GetCurrentUserResponse)(nil), // 14: openshell.v1.GetCurrentUserResponse - (*GetGatewayInfoRequest)(nil), // 15: openshell.v1.GetGatewayInfoRequest - (*GetGatewayInfoResponse)(nil), // 16: openshell.v1.GetGatewayInfoResponse - (*ComputeDriverInfo)(nil), // 17: openshell.v1.ComputeDriverInfo - (*ComputeDriverCapabilities)(nil), // 18: openshell.v1.ComputeDriverCapabilities - (*Sandbox)(nil), // 19: openshell.v1.Sandbox - (*SandboxSpec)(nil), // 20: openshell.v1.SandboxSpec - (*MainProcessSpec)(nil), // 21: openshell.v1.MainProcessSpec - (*ResourceRequirements)(nil), // 22: openshell.v1.ResourceRequirements - (*GpuResourceRequirements)(nil), // 23: openshell.v1.GpuResourceRequirements - (*SandboxTemplate)(nil), // 24: openshell.v1.SandboxTemplate - (*SandboxStatus)(nil), // 25: openshell.v1.SandboxStatus - (*MainProcessStatus)(nil), // 26: openshell.v1.MainProcessStatus - (*SandboxCondition)(nil), // 27: openshell.v1.SandboxCondition - (*PlatformEvent)(nil), // 28: openshell.v1.PlatformEvent - (*CreateSandboxRequest)(nil), // 29: openshell.v1.CreateSandboxRequest - (*GetSandboxRequest)(nil), // 30: openshell.v1.GetSandboxRequest - (*ListSandboxesRequest)(nil), // 31: openshell.v1.ListSandboxesRequest - (*ListSandboxProvidersRequest)(nil), // 32: openshell.v1.ListSandboxProvidersRequest - (*AttachSandboxProviderRequest)(nil), // 33: openshell.v1.AttachSandboxProviderRequest - (*DetachSandboxProviderRequest)(nil), // 34: openshell.v1.DetachSandboxProviderRequest - (*DeleteSandboxRequest)(nil), // 35: openshell.v1.DeleteSandboxRequest - (*StopSandboxRequest)(nil), // 36: openshell.v1.StopSandboxRequest - (*StartSandboxRequest)(nil), // 37: openshell.v1.StartSandboxRequest - (*SandboxResponse)(nil), // 38: openshell.v1.SandboxResponse - (*ListSandboxesResponse)(nil), // 39: openshell.v1.ListSandboxesResponse - (*ListSandboxProvidersResponse)(nil), // 40: openshell.v1.ListSandboxProvidersResponse - (*AttachSandboxProviderResponse)(nil), // 41: openshell.v1.AttachSandboxProviderResponse - (*DetachSandboxProviderResponse)(nil), // 42: openshell.v1.DetachSandboxProviderResponse - (*DeleteSandboxResponse)(nil), // 43: openshell.v1.DeleteSandboxResponse - (*CreateSshSessionRequest)(nil), // 44: openshell.v1.CreateSshSessionRequest - (*CreateSshSessionResponse)(nil), // 45: openshell.v1.CreateSshSessionResponse - (*ExposeServiceRequest)(nil), // 46: openshell.v1.ExposeServiceRequest - (*GetServiceRequest)(nil), // 47: openshell.v1.GetServiceRequest - (*ListServicesRequest)(nil), // 48: openshell.v1.ListServicesRequest - (*ListServicesResponse)(nil), // 49: openshell.v1.ListServicesResponse - (*DeleteServiceRequest)(nil), // 50: openshell.v1.DeleteServiceRequest - (*DeleteServiceResponse)(nil), // 51: openshell.v1.DeleteServiceResponse - (*ServiceEndpoint)(nil), // 52: openshell.v1.ServiceEndpoint - (*ServiceEndpointResponse)(nil), // 53: openshell.v1.ServiceEndpointResponse - (*RevokeSshSessionRequest)(nil), // 54: openshell.v1.RevokeSshSessionRequest - (*RevokeSshSessionResponse)(nil), // 55: openshell.v1.RevokeSshSessionResponse - (*ExecSandboxRequest)(nil), // 56: openshell.v1.ExecSandboxRequest - (*ExecSandboxStdout)(nil), // 57: openshell.v1.ExecSandboxStdout - (*ExecSandboxStderr)(nil), // 58: openshell.v1.ExecSandboxStderr - (*ExecSandboxExit)(nil), // 59: openshell.v1.ExecSandboxExit - (*ExecSandboxEvent)(nil), // 60: openshell.v1.ExecSandboxEvent - (*TcpForwardInit)(nil), // 61: openshell.v1.TcpForwardInit - (*TcpForwardFrame)(nil), // 62: openshell.v1.TcpForwardFrame - (*ExecSandboxInput)(nil), // 63: openshell.v1.ExecSandboxInput - (*ExecSandboxWindowResize)(nil), // 64: openshell.v1.ExecSandboxWindowResize - (*SshSession)(nil), // 65: openshell.v1.SshSession - (*WatchSandboxRequest)(nil), // 66: openshell.v1.WatchSandboxRequest - (*SandboxStreamEvent)(nil), // 67: openshell.v1.SandboxStreamEvent - (*SandboxLogLine)(nil), // 68: openshell.v1.SandboxLogLine - (*SandboxStreamWarning)(nil), // 69: openshell.v1.SandboxStreamWarning - (*CreateProviderRequest)(nil), // 70: openshell.v1.CreateProviderRequest - (*GetProviderRequest)(nil), // 71: openshell.v1.GetProviderRequest - (*ListProvidersRequest)(nil), // 72: openshell.v1.ListProvidersRequest - (*UpdateProviderRequest)(nil), // 73: openshell.v1.UpdateProviderRequest - (*DeleteProviderRequest)(nil), // 74: openshell.v1.DeleteProviderRequest - (*ProviderResponse)(nil), // 75: openshell.v1.ProviderResponse - (*ListProvidersResponse)(nil), // 76: openshell.v1.ListProvidersResponse - (*ListProviderProfilesRequest)(nil), // 77: openshell.v1.ListProviderProfilesRequest - (*GetProviderProfileRequest)(nil), // 78: openshell.v1.GetProviderProfileRequest - (*ProviderProfileImportItem)(nil), // 79: openshell.v1.ProviderProfileImportItem - (*ProviderProfileDiagnostic)(nil), // 80: openshell.v1.ProviderProfileDiagnostic - (*ProviderCredentialTokenGrantAudienceOverride)(nil), // 81: openshell.v1.ProviderCredentialTokenGrantAudienceOverride - (*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 - (*GetProviderRefreshStatusRequest)(nil), // 90: openshell.v1.GetProviderRefreshStatusRequest - (*GetProviderRefreshStatusResponse)(nil), // 91: openshell.v1.GetProviderRefreshStatusResponse - (*ConfigureProviderRefreshRequest)(nil), // 92: openshell.v1.ConfigureProviderRefreshRequest - (*ConfigureProviderRefreshResponse)(nil), // 93: openshell.v1.ConfigureProviderRefreshResponse - (*RotateProviderCredentialRequest)(nil), // 94: openshell.v1.RotateProviderCredentialRequest - (*RotateProviderCredentialResponse)(nil), // 95: openshell.v1.RotateProviderCredentialResponse - (*DeleteProviderRefreshRequest)(nil), // 96: openshell.v1.DeleteProviderRefreshRequest - (*DeleteProviderRefreshResponse)(nil), // 97: openshell.v1.DeleteProviderRefreshResponse - (*ProviderProfile)(nil), // 98: openshell.v1.ProviderProfile - (*StoredProviderProfile)(nil), // 99: openshell.v1.StoredProviderProfile - (*ProviderProfileResponse)(nil), // 100: openshell.v1.ProviderProfileResponse - (*ListProviderProfilesResponse)(nil), // 101: openshell.v1.ListProviderProfilesResponse - (*ImportProviderProfilesRequest)(nil), // 102: openshell.v1.ImportProviderProfilesRequest - (*ImportProviderProfilesResponse)(nil), // 103: openshell.v1.ImportProviderProfilesResponse - (*UpdateProviderProfilesRequest)(nil), // 104: openshell.v1.UpdateProviderProfilesRequest - (*UpdateProviderProfilesResponse)(nil), // 105: openshell.v1.UpdateProviderProfilesResponse - (*LintProviderProfilesRequest)(nil), // 106: openshell.v1.LintProviderProfilesRequest - (*LintProviderProfilesResponse)(nil), // 107: openshell.v1.LintProviderProfilesResponse - (*DeleteProviderResponse)(nil), // 108: openshell.v1.DeleteProviderResponse - (*DeleteProviderProfileRequest)(nil), // 109: openshell.v1.DeleteProviderProfileRequest - (*DeleteProviderProfileResponse)(nil), // 110: openshell.v1.DeleteProviderProfileResponse - (*GetSandboxProviderEnvironmentRequest)(nil), // 111: openshell.v1.GetSandboxProviderEnvironmentRequest - (*StaticCredentialEndpointBinding)(nil), // 112: openshell.v1.StaticCredentialEndpointBinding - (*StaticCredentialBinding)(nil), // 113: openshell.v1.StaticCredentialBinding - (*GetSandboxProviderEnvironmentResponse)(nil), // 114: openshell.v1.GetSandboxProviderEnvironmentResponse - (*UpdateConfigRequest)(nil), // 115: openshell.v1.UpdateConfigRequest - (*PolicyMergeOperation)(nil), // 116: openshell.v1.PolicyMergeOperation - (*AddNetworkRule)(nil), // 117: openshell.v1.AddNetworkRule - (*RemoveNetworkEndpoint)(nil), // 118: openshell.v1.RemoveNetworkEndpoint - (*RemoveNetworkRule)(nil), // 119: openshell.v1.RemoveNetworkRule - (*AddDenyRules)(nil), // 120: openshell.v1.AddDenyRules - (*AddAllowRules)(nil), // 121: openshell.v1.AddAllowRules - (*RemoveNetworkBinary)(nil), // 122: openshell.v1.RemoveNetworkBinary - (*UpdateConfigResponse)(nil), // 123: openshell.v1.UpdateConfigResponse - (*GetSandboxPolicyStatusRequest)(nil), // 124: openshell.v1.GetSandboxPolicyStatusRequest - (*GetSandboxPolicyStatusResponse)(nil), // 125: openshell.v1.GetSandboxPolicyStatusResponse - (*ListSandboxPoliciesRequest)(nil), // 126: openshell.v1.ListSandboxPoliciesRequest - (*ListSandboxPoliciesResponse)(nil), // 127: openshell.v1.ListSandboxPoliciesResponse - (*ReportPolicyStatusRequest)(nil), // 128: openshell.v1.ReportPolicyStatusRequest - (*ReportPolicyStatusResponse)(nil), // 129: openshell.v1.ReportPolicyStatusResponse - (*SandboxPolicyRevision)(nil), // 130: openshell.v1.SandboxPolicyRevision - (*GetSandboxLogsRequest)(nil), // 131: openshell.v1.GetSandboxLogsRequest - (*PushSandboxLogsRequest)(nil), // 132: openshell.v1.PushSandboxLogsRequest - (*PushSandboxLogsResponse)(nil), // 133: openshell.v1.PushSandboxLogsResponse - (*GetSandboxLogsResponse)(nil), // 134: openshell.v1.GetSandboxLogsResponse - (*SupervisorMessage)(nil), // 135: openshell.v1.SupervisorMessage - (*GatewayMessage)(nil), // 136: openshell.v1.GatewayMessage - (*SupervisorHello)(nil), // 137: openshell.v1.SupervisorHello - (*SessionAccepted)(nil), // 138: openshell.v1.SessionAccepted - (*SessionRejected)(nil), // 139: openshell.v1.SessionRejected - (*SupervisorHeartbeat)(nil), // 140: openshell.v1.SupervisorHeartbeat - (*GatewayHeartbeat)(nil), // 141: openshell.v1.GatewayHeartbeat - (*MainProcessExit)(nil), // 142: openshell.v1.MainProcessExit - (*MainProcessExitAck)(nil), // 143: openshell.v1.MainProcessExitAck - (*RelayOpen)(nil), // 144: openshell.v1.RelayOpen - (*SshRelayTarget)(nil), // 145: openshell.v1.SshRelayTarget - (*TcpRelayTarget)(nil), // 146: openshell.v1.TcpRelayTarget - (*RelayInit)(nil), // 147: openshell.v1.RelayInit - (*RelayFrame)(nil), // 148: openshell.v1.RelayFrame - (*RelayOpenResult)(nil), // 149: openshell.v1.RelayOpenResult - (*RelayClose)(nil), // 150: openshell.v1.RelayClose - (*L7RequestSample)(nil), // 151: openshell.v1.L7RequestSample - (*DenialSummary)(nil), // 152: openshell.v1.DenialSummary - (*DenialGroupCount)(nil), // 153: openshell.v1.DenialGroupCount - (*NetworkActivitySummary)(nil), // 154: openshell.v1.NetworkActivitySummary - (*PolicyChunk)(nil), // 155: openshell.v1.PolicyChunk - (*DraftPolicyUpdate)(nil), // 156: openshell.v1.DraftPolicyUpdate - (*SubmitPolicyAnalysisRequest)(nil), // 157: openshell.v1.SubmitPolicyAnalysisRequest - (*SubmitPolicyAnalysisResponse)(nil), // 158: openshell.v1.SubmitPolicyAnalysisResponse - (*GetDraftPolicyRequest)(nil), // 159: openshell.v1.GetDraftPolicyRequest - (*GetDraftPolicyResponse)(nil), // 160: openshell.v1.GetDraftPolicyResponse - (*ApproveDraftChunkRequest)(nil), // 161: openshell.v1.ApproveDraftChunkRequest - (*ApproveDraftChunkResponse)(nil), // 162: openshell.v1.ApproveDraftChunkResponse - (*RejectDraftChunkRequest)(nil), // 163: openshell.v1.RejectDraftChunkRequest - (*RejectDraftChunkResponse)(nil), // 164: openshell.v1.RejectDraftChunkResponse - (*ApproveAllDraftChunksRequest)(nil), // 165: openshell.v1.ApproveAllDraftChunksRequest - (*ApproveAllDraftChunksResponse)(nil), // 166: openshell.v1.ApproveAllDraftChunksResponse - (*EditDraftChunkRequest)(nil), // 167: openshell.v1.EditDraftChunkRequest - (*EditDraftChunkResponse)(nil), // 168: openshell.v1.EditDraftChunkResponse - (*UndoDraftChunkRequest)(nil), // 169: openshell.v1.UndoDraftChunkRequest - (*UndoDraftChunkResponse)(nil), // 170: openshell.v1.UndoDraftChunkResponse - (*ClearDraftChunksRequest)(nil), // 171: openshell.v1.ClearDraftChunksRequest - (*ClearDraftChunksResponse)(nil), // 172: openshell.v1.ClearDraftChunksResponse - (*GetDraftHistoryRequest)(nil), // 173: openshell.v1.GetDraftHistoryRequest - (*DraftHistoryEntry)(nil), // 174: openshell.v1.DraftHistoryEntry - (*GetDraftHistoryResponse)(nil), // 175: openshell.v1.GetDraftHistoryResponse - (*PolicyRevisionPayload)(nil), // 176: openshell.v1.PolicyRevisionPayload - (*DraftChunkPayload)(nil), // 177: openshell.v1.DraftChunkPayload - (*StoredPolicyRevision)(nil), // 178: openshell.v1.StoredPolicyRevision - (*StoredDraftChunk)(nil), // 179: openshell.v1.StoredDraftChunk - (*CreateWorkspaceRequest)(nil), // 180: openshell.v1.CreateWorkspaceRequest - (*CreateWorkspaceResponse)(nil), // 181: openshell.v1.CreateWorkspaceResponse - (*GetWorkspaceRequest)(nil), // 182: openshell.v1.GetWorkspaceRequest - (*GetWorkspaceResponse)(nil), // 183: openshell.v1.GetWorkspaceResponse - (*ListWorkspacesRequest)(nil), // 184: openshell.v1.ListWorkspacesRequest - (*ListWorkspacesResponse)(nil), // 185: openshell.v1.ListWorkspacesResponse - (*DeleteWorkspaceRequest)(nil), // 186: openshell.v1.DeleteWorkspaceRequest - (*DeleteWorkspaceResponse)(nil), // 187: openshell.v1.DeleteWorkspaceResponse - (*WorkspaceMember)(nil), // 188: openshell.v1.WorkspaceMember - (*AddWorkspaceMemberRequest)(nil), // 189: openshell.v1.AddWorkspaceMemberRequest - (*AddWorkspaceMemberResponse)(nil), // 190: openshell.v1.AddWorkspaceMemberResponse - (*RemoveWorkspaceMemberRequest)(nil), // 191: openshell.v1.RemoveWorkspaceMemberRequest - (*RemoveWorkspaceMemberResponse)(nil), // 192: openshell.v1.RemoveWorkspaceMemberResponse - (*ListWorkspaceMembersRequest)(nil), // 193: openshell.v1.ListWorkspaceMembersRequest - (*ListWorkspaceMembersResponse)(nil), // 194: openshell.v1.ListWorkspaceMembersResponse - (*ExtensionServiceCredential)(nil), // 195: openshell.v1.ExtensionServiceCredential - nil, // 196: openshell.v1.SandboxSpec.EnvironmentEntry - nil, // 197: openshell.v1.MainProcessSpec.EnvironmentEntry - nil, // 198: openshell.v1.SandboxTemplate.LabelsEntry - nil, // 199: openshell.v1.SandboxTemplate.AnnotationsEntry - nil, // 200: openshell.v1.SandboxTemplate.EnvironmentEntry - nil, // 201: openshell.v1.PlatformEvent.MetadataEntry - nil, // 202: openshell.v1.CreateSandboxRequest.LabelsEntry - nil, // 203: openshell.v1.CreateSandboxRequest.AnnotationsEntry - nil, // 204: openshell.v1.ExecSandboxRequest.EnvironmentEntry - nil, // 205: openshell.v1.SandboxLogLine.FieldsEntry - nil, // 206: openshell.v1.UpdateProviderRequest.CredentialExpiresAtMsEntry - nil, // 207: openshell.v1.StoredProviderCredentialRefreshState.MaterialEntry - nil, // 208: openshell.v1.StoredProviderCredentialRefreshState.AdditionalOutputKeysEntry - nil, // 209: openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry - nil, // 210: openshell.v1.ProviderProfile.AnnotationsEntry - nil, // 211: openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry - nil, // 212: openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpiresAtMsEntry - nil, // 213: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry - nil, // 214: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry - nil, // 215: openshell.v1.UpdateConfigRequest.AnnotationsEntry - nil, // 216: openshell.v1.UpdateConfigResponse.AnnotationsEntry - nil, // 217: openshell.v1.SandboxPolicyRevision.ProvenanceEntry - nil, // 218: openshell.v1.PolicyRevisionPayload.ProvenanceEntry - nil, // 219: openshell.v1.StoredPolicyRevision.ProvenanceEntry - nil, // 220: openshell.v1.CreateWorkspaceRequest.LabelsEntry - (*datamodelv1.ObjectMeta)(nil), // 221: openshell.datamodel.v1.ObjectMeta - (*sandboxv1.SandboxPolicy)(nil), // 222: openshell.sandbox.v1.SandboxPolicy - (*structpb.Struct)(nil), // 223: google.protobuf.Struct - (*datamodelv1.Provider)(nil), // 224: openshell.datamodel.v1.Provider - (*sandboxv1.NetworkEndpoint)(nil), // 225: openshell.sandbox.v1.NetworkEndpoint - (*sandboxv1.NetworkBinary)(nil), // 226: openshell.sandbox.v1.NetworkBinary - (*sandboxv1.SettingValue)(nil), // 227: openshell.sandbox.v1.SettingValue - (*sandboxv1.NetworkPolicyRule)(nil), // 228: openshell.sandbox.v1.NetworkPolicyRule - (*sandboxv1.L7DenyRule)(nil), // 229: openshell.sandbox.v1.L7DenyRule - (*sandboxv1.L7Rule)(nil), // 230: openshell.sandbox.v1.L7Rule - (*datamodelv1.Workspace)(nil), // 231: openshell.datamodel.v1.Workspace - (*sandboxv1.GetSandboxConfigRequest)(nil), // 232: openshell.sandbox.v1.GetSandboxConfigRequest - (*sandboxv1.GetGatewayConfigRequest)(nil), // 233: openshell.sandbox.v1.GetGatewayConfigRequest - (*sandboxv1.GetSandboxConfigResponse)(nil), // 234: openshell.sandbox.v1.GetSandboxConfigResponse - (*sandboxv1.GetGatewayConfigResponse)(nil), // 235: openshell.sandbox.v1.GetGatewayConfigResponse + (SandboxPhase)(0), // 0: openshell.v1.SandboxPhase + (ProviderCredentialRefreshStrategy)(0), // 1: openshell.v1.ProviderCredentialRefreshStrategy + (ProviderProfileCategory)(0), // 2: openshell.v1.ProviderProfileCategory + (PolicyStatus)(0), // 3: openshell.v1.PolicyStatus + (ServiceStatus)(0), // 4: openshell.v1.ServiceStatus + (WorkspaceRole)(0), // 5: openshell.v1.WorkspaceRole + (*IssueSandboxTokenRequest)(nil), // 6: openshell.v1.IssueSandboxTokenRequest + (*IssueSandboxTokenResponse)(nil), // 7: openshell.v1.IssueSandboxTokenResponse + (*RefreshSandboxTokenRequest)(nil), // 8: openshell.v1.RefreshSandboxTokenRequest + (*RefreshSandboxTokenResponse)(nil), // 9: openshell.v1.RefreshSandboxTokenResponse + (*HealthRequest)(nil), // 10: openshell.v1.HealthRequest + (*HealthResponse)(nil), // 11: openshell.v1.HealthResponse + (*GetCurrentUserRequest)(nil), // 12: openshell.v1.GetCurrentUserRequest + (*GetCurrentUserResponse)(nil), // 13: openshell.v1.GetCurrentUserResponse + (*GetGatewayInfoRequest)(nil), // 14: openshell.v1.GetGatewayInfoRequest + (*GetGatewayInfoResponse)(nil), // 15: openshell.v1.GetGatewayInfoResponse + (*ComputeDriverInfo)(nil), // 16: openshell.v1.ComputeDriverInfo + (*ComputeDriverCapabilities)(nil), // 17: openshell.v1.ComputeDriverCapabilities + (*Sandbox)(nil), // 18: openshell.v1.Sandbox + (*SandboxSpec)(nil), // 19: openshell.v1.SandboxSpec + (*ResourceRequirements)(nil), // 20: openshell.v1.ResourceRequirements + (*GpuResourceRequirements)(nil), // 21: openshell.v1.GpuResourceRequirements + (*SandboxTemplate)(nil), // 22: openshell.v1.SandboxTemplate + (*SandboxStatus)(nil), // 23: openshell.v1.SandboxStatus + (*SandboxCondition)(nil), // 24: openshell.v1.SandboxCondition + (*PlatformEvent)(nil), // 25: openshell.v1.PlatformEvent + (*CreateSandboxRequest)(nil), // 26: openshell.v1.CreateSandboxRequest + (*GetSandboxRequest)(nil), // 27: openshell.v1.GetSandboxRequest + (*ListSandboxesRequest)(nil), // 28: openshell.v1.ListSandboxesRequest + (*ListSandboxProvidersRequest)(nil), // 29: openshell.v1.ListSandboxProvidersRequest + (*AttachSandboxProviderRequest)(nil), // 30: openshell.v1.AttachSandboxProviderRequest + (*DetachSandboxProviderRequest)(nil), // 31: openshell.v1.DetachSandboxProviderRequest + (*DeleteSandboxRequest)(nil), // 32: openshell.v1.DeleteSandboxRequest + (*StopSandboxRequest)(nil), // 33: openshell.v1.StopSandboxRequest + (*StartSandboxRequest)(nil), // 34: openshell.v1.StartSandboxRequest + (*SandboxResponse)(nil), // 35: openshell.v1.SandboxResponse + (*ListSandboxesResponse)(nil), // 36: openshell.v1.ListSandboxesResponse + (*ListSandboxProvidersResponse)(nil), // 37: openshell.v1.ListSandboxProvidersResponse + (*AttachSandboxProviderResponse)(nil), // 38: openshell.v1.AttachSandboxProviderResponse + (*DetachSandboxProviderResponse)(nil), // 39: openshell.v1.DetachSandboxProviderResponse + (*DeleteSandboxResponse)(nil), // 40: openshell.v1.DeleteSandboxResponse + (*CreateSshSessionRequest)(nil), // 41: openshell.v1.CreateSshSessionRequest + (*CreateSshSessionResponse)(nil), // 42: openshell.v1.CreateSshSessionResponse + (*ExposeServiceRequest)(nil), // 43: openshell.v1.ExposeServiceRequest + (*GetServiceRequest)(nil), // 44: openshell.v1.GetServiceRequest + (*ListServicesRequest)(nil), // 45: openshell.v1.ListServicesRequest + (*ListServicesResponse)(nil), // 46: openshell.v1.ListServicesResponse + (*DeleteServiceRequest)(nil), // 47: openshell.v1.DeleteServiceRequest + (*DeleteServiceResponse)(nil), // 48: openshell.v1.DeleteServiceResponse + (*ServiceEndpoint)(nil), // 49: openshell.v1.ServiceEndpoint + (*ServiceEndpointResponse)(nil), // 50: openshell.v1.ServiceEndpointResponse + (*RevokeSshSessionRequest)(nil), // 51: openshell.v1.RevokeSshSessionRequest + (*RevokeSshSessionResponse)(nil), // 52: openshell.v1.RevokeSshSessionResponse + (*ExecSandboxRequest)(nil), // 53: openshell.v1.ExecSandboxRequest + (*ExecSandboxStdout)(nil), // 54: openshell.v1.ExecSandboxStdout + (*ExecSandboxStderr)(nil), // 55: openshell.v1.ExecSandboxStderr + (*ExecSandboxExit)(nil), // 56: openshell.v1.ExecSandboxExit + (*ExecSandboxEvent)(nil), // 57: openshell.v1.ExecSandboxEvent + (*TcpForwardInit)(nil), // 58: openshell.v1.TcpForwardInit + (*TcpForwardFrame)(nil), // 59: openshell.v1.TcpForwardFrame + (*ExecSandboxInput)(nil), // 60: openshell.v1.ExecSandboxInput + (*ExecSandboxWindowResize)(nil), // 61: openshell.v1.ExecSandboxWindowResize + (*SshSession)(nil), // 62: openshell.v1.SshSession + (*WatchSandboxRequest)(nil), // 63: openshell.v1.WatchSandboxRequest + (*SandboxStreamEvent)(nil), // 64: openshell.v1.SandboxStreamEvent + (*SandboxLogLine)(nil), // 65: openshell.v1.SandboxLogLine + (*SandboxStreamWarning)(nil), // 66: openshell.v1.SandboxStreamWarning + (*CreateProviderRequest)(nil), // 67: openshell.v1.CreateProviderRequest + (*GetProviderRequest)(nil), // 68: openshell.v1.GetProviderRequest + (*ListProvidersRequest)(nil), // 69: openshell.v1.ListProvidersRequest + (*UpdateProviderRequest)(nil), // 70: openshell.v1.UpdateProviderRequest + (*DeleteProviderRequest)(nil), // 71: openshell.v1.DeleteProviderRequest + (*ProviderResponse)(nil), // 72: openshell.v1.ProviderResponse + (*ListProvidersResponse)(nil), // 73: openshell.v1.ListProvidersResponse + (*ListProviderProfilesRequest)(nil), // 74: openshell.v1.ListProviderProfilesRequest + (*GetProviderProfileRequest)(nil), // 75: openshell.v1.GetProviderProfileRequest + (*ProviderProfileImportItem)(nil), // 76: openshell.v1.ProviderProfileImportItem + (*ProviderProfileDiagnostic)(nil), // 77: openshell.v1.ProviderProfileDiagnostic + (*ProviderCredentialTokenGrantAudienceOverride)(nil), // 78: openshell.v1.ProviderCredentialTokenGrantAudienceOverride + (*ProviderCredentialTokenGrant)(nil), // 79: openshell.v1.ProviderCredentialTokenGrant + (*ProviderProfileCredential)(nil), // 80: openshell.v1.ProviderProfileCredential + (*ProviderCredentialRefreshMaterial)(nil), // 81: openshell.v1.ProviderCredentialRefreshMaterial + (*ProviderCredentialRefreshOutput)(nil), // 82: openshell.v1.ProviderCredentialRefreshOutput + (*ProviderCredentialRefresh)(nil), // 83: openshell.v1.ProviderCredentialRefresh + (*ProviderCredentialRefreshStatus)(nil), // 84: openshell.v1.ProviderCredentialRefreshStatus + (*ProviderProfileDiscovery)(nil), // 85: openshell.v1.ProviderProfileDiscovery + (*StoredProviderCredentialRefreshState)(nil), // 86: openshell.v1.StoredProviderCredentialRefreshState + (*GetProviderRefreshStatusRequest)(nil), // 87: openshell.v1.GetProviderRefreshStatusRequest + (*GetProviderRefreshStatusResponse)(nil), // 88: openshell.v1.GetProviderRefreshStatusResponse + (*ConfigureProviderRefreshRequest)(nil), // 89: openshell.v1.ConfigureProviderRefreshRequest + (*ConfigureProviderRefreshResponse)(nil), // 90: openshell.v1.ConfigureProviderRefreshResponse + (*RotateProviderCredentialRequest)(nil), // 91: openshell.v1.RotateProviderCredentialRequest + (*RotateProviderCredentialResponse)(nil), // 92: openshell.v1.RotateProviderCredentialResponse + (*DeleteProviderRefreshRequest)(nil), // 93: openshell.v1.DeleteProviderRefreshRequest + (*DeleteProviderRefreshResponse)(nil), // 94: openshell.v1.DeleteProviderRefreshResponse + (*ProviderProfile)(nil), // 95: openshell.v1.ProviderProfile + (*StoredProviderProfile)(nil), // 96: openshell.v1.StoredProviderProfile + (*ProviderProfileResponse)(nil), // 97: openshell.v1.ProviderProfileResponse + (*ListProviderProfilesResponse)(nil), // 98: openshell.v1.ListProviderProfilesResponse + (*ImportProviderProfilesRequest)(nil), // 99: openshell.v1.ImportProviderProfilesRequest + (*ImportProviderProfilesResponse)(nil), // 100: openshell.v1.ImportProviderProfilesResponse + (*UpdateProviderProfilesRequest)(nil), // 101: openshell.v1.UpdateProviderProfilesRequest + (*UpdateProviderProfilesResponse)(nil), // 102: openshell.v1.UpdateProviderProfilesResponse + (*LintProviderProfilesRequest)(nil), // 103: openshell.v1.LintProviderProfilesRequest + (*LintProviderProfilesResponse)(nil), // 104: openshell.v1.LintProviderProfilesResponse + (*DeleteProviderResponse)(nil), // 105: openshell.v1.DeleteProviderResponse + (*DeleteProviderProfileRequest)(nil), // 106: openshell.v1.DeleteProviderProfileRequest + (*DeleteProviderProfileResponse)(nil), // 107: openshell.v1.DeleteProviderProfileResponse + (*GetSandboxProviderEnvironmentRequest)(nil), // 108: openshell.v1.GetSandboxProviderEnvironmentRequest + (*StaticCredentialEndpointBinding)(nil), // 109: openshell.v1.StaticCredentialEndpointBinding + (*StaticCredentialBinding)(nil), // 110: openshell.v1.StaticCredentialBinding + (*GetSandboxProviderEnvironmentResponse)(nil), // 111: openshell.v1.GetSandboxProviderEnvironmentResponse + (*UpdateConfigRequest)(nil), // 112: openshell.v1.UpdateConfigRequest + (*PolicyMergeOperation)(nil), // 113: openshell.v1.PolicyMergeOperation + (*AddNetworkRule)(nil), // 114: openshell.v1.AddNetworkRule + (*RemoveNetworkEndpoint)(nil), // 115: openshell.v1.RemoveNetworkEndpoint + (*RemoveNetworkRule)(nil), // 116: openshell.v1.RemoveNetworkRule + (*AddDenyRules)(nil), // 117: openshell.v1.AddDenyRules + (*AddAllowRules)(nil), // 118: openshell.v1.AddAllowRules + (*RemoveNetworkBinary)(nil), // 119: openshell.v1.RemoveNetworkBinary + (*UpdateConfigResponse)(nil), // 120: openshell.v1.UpdateConfigResponse + (*GetSandboxPolicyStatusRequest)(nil), // 121: openshell.v1.GetSandboxPolicyStatusRequest + (*GetSandboxPolicyStatusResponse)(nil), // 122: openshell.v1.GetSandboxPolicyStatusResponse + (*ListSandboxPoliciesRequest)(nil), // 123: openshell.v1.ListSandboxPoliciesRequest + (*ListSandboxPoliciesResponse)(nil), // 124: openshell.v1.ListSandboxPoliciesResponse + (*ReportPolicyStatusRequest)(nil), // 125: openshell.v1.ReportPolicyStatusRequest + (*ReportPolicyStatusResponse)(nil), // 126: openshell.v1.ReportPolicyStatusResponse + (*SandboxPolicyRevision)(nil), // 127: openshell.v1.SandboxPolicyRevision + (*GetSandboxLogsRequest)(nil), // 128: openshell.v1.GetSandboxLogsRequest + (*PushSandboxLogsRequest)(nil), // 129: openshell.v1.PushSandboxLogsRequest + (*PushSandboxLogsResponse)(nil), // 130: openshell.v1.PushSandboxLogsResponse + (*GetSandboxLogsResponse)(nil), // 131: openshell.v1.GetSandboxLogsResponse + (*SupervisorMessage)(nil), // 132: openshell.v1.SupervisorMessage + (*GatewayMessage)(nil), // 133: openshell.v1.GatewayMessage + (*SupervisorHello)(nil), // 134: openshell.v1.SupervisorHello + (*SessionAccepted)(nil), // 135: openshell.v1.SessionAccepted + (*SessionRejected)(nil), // 136: openshell.v1.SessionRejected + (*SupervisorHeartbeat)(nil), // 137: openshell.v1.SupervisorHeartbeat + (*GatewayHeartbeat)(nil), // 138: openshell.v1.GatewayHeartbeat + (*ReportMainProcessExitRequest)(nil), // 139: openshell.v1.ReportMainProcessExitRequest + (*ReportMainProcessExitResponse)(nil), // 140: openshell.v1.ReportMainProcessExitResponse + (*RelayOpen)(nil), // 141: openshell.v1.RelayOpen + (*SshRelayTarget)(nil), // 142: openshell.v1.SshRelayTarget + (*TcpRelayTarget)(nil), // 143: openshell.v1.TcpRelayTarget + (*RelayInit)(nil), // 144: openshell.v1.RelayInit + (*RelayFrame)(nil), // 145: openshell.v1.RelayFrame + (*RelayOpenResult)(nil), // 146: openshell.v1.RelayOpenResult + (*RelayClose)(nil), // 147: openshell.v1.RelayClose + (*L7RequestSample)(nil), // 148: openshell.v1.L7RequestSample + (*DenialSummary)(nil), // 149: openshell.v1.DenialSummary + (*DenialGroupCount)(nil), // 150: openshell.v1.DenialGroupCount + (*NetworkActivitySummary)(nil), // 151: openshell.v1.NetworkActivitySummary + (*PolicyChunk)(nil), // 152: openshell.v1.PolicyChunk + (*DraftPolicyUpdate)(nil), // 153: openshell.v1.DraftPolicyUpdate + (*SubmitPolicyAnalysisRequest)(nil), // 154: openshell.v1.SubmitPolicyAnalysisRequest + (*SubmitPolicyAnalysisResponse)(nil), // 155: openshell.v1.SubmitPolicyAnalysisResponse + (*GetDraftPolicyRequest)(nil), // 156: openshell.v1.GetDraftPolicyRequest + (*GetDraftPolicyResponse)(nil), // 157: openshell.v1.GetDraftPolicyResponse + (*ApproveDraftChunkRequest)(nil), // 158: openshell.v1.ApproveDraftChunkRequest + (*ApproveDraftChunkResponse)(nil), // 159: openshell.v1.ApproveDraftChunkResponse + (*RejectDraftChunkRequest)(nil), // 160: openshell.v1.RejectDraftChunkRequest + (*RejectDraftChunkResponse)(nil), // 161: openshell.v1.RejectDraftChunkResponse + (*ApproveAllDraftChunksRequest)(nil), // 162: openshell.v1.ApproveAllDraftChunksRequest + (*ApproveAllDraftChunksResponse)(nil), // 163: openshell.v1.ApproveAllDraftChunksResponse + (*EditDraftChunkRequest)(nil), // 164: openshell.v1.EditDraftChunkRequest + (*EditDraftChunkResponse)(nil), // 165: openshell.v1.EditDraftChunkResponse + (*UndoDraftChunkRequest)(nil), // 166: openshell.v1.UndoDraftChunkRequest + (*UndoDraftChunkResponse)(nil), // 167: openshell.v1.UndoDraftChunkResponse + (*ClearDraftChunksRequest)(nil), // 168: openshell.v1.ClearDraftChunksRequest + (*ClearDraftChunksResponse)(nil), // 169: openshell.v1.ClearDraftChunksResponse + (*GetDraftHistoryRequest)(nil), // 170: openshell.v1.GetDraftHistoryRequest + (*DraftHistoryEntry)(nil), // 171: openshell.v1.DraftHistoryEntry + (*GetDraftHistoryResponse)(nil), // 172: openshell.v1.GetDraftHistoryResponse + (*PolicyRevisionPayload)(nil), // 173: openshell.v1.PolicyRevisionPayload + (*DraftChunkPayload)(nil), // 174: openshell.v1.DraftChunkPayload + (*StoredPolicyRevision)(nil), // 175: openshell.v1.StoredPolicyRevision + (*StoredDraftChunk)(nil), // 176: openshell.v1.StoredDraftChunk + (*CreateWorkspaceRequest)(nil), // 177: openshell.v1.CreateWorkspaceRequest + (*CreateWorkspaceResponse)(nil), // 178: openshell.v1.CreateWorkspaceResponse + (*GetWorkspaceRequest)(nil), // 179: openshell.v1.GetWorkspaceRequest + (*GetWorkspaceResponse)(nil), // 180: openshell.v1.GetWorkspaceResponse + (*ListWorkspacesRequest)(nil), // 181: openshell.v1.ListWorkspacesRequest + (*ListWorkspacesResponse)(nil), // 182: openshell.v1.ListWorkspacesResponse + (*DeleteWorkspaceRequest)(nil), // 183: openshell.v1.DeleteWorkspaceRequest + (*DeleteWorkspaceResponse)(nil), // 184: openshell.v1.DeleteWorkspaceResponse + (*WorkspaceMember)(nil), // 185: openshell.v1.WorkspaceMember + (*AddWorkspaceMemberRequest)(nil), // 186: openshell.v1.AddWorkspaceMemberRequest + (*AddWorkspaceMemberResponse)(nil), // 187: openshell.v1.AddWorkspaceMemberResponse + (*RemoveWorkspaceMemberRequest)(nil), // 188: openshell.v1.RemoveWorkspaceMemberRequest + (*RemoveWorkspaceMemberResponse)(nil), // 189: openshell.v1.RemoveWorkspaceMemberResponse + (*ListWorkspaceMembersRequest)(nil), // 190: openshell.v1.ListWorkspaceMembersRequest + (*ListWorkspaceMembersResponse)(nil), // 191: openshell.v1.ListWorkspaceMembersResponse + (*ExtensionServiceCredential)(nil), // 192: openshell.v1.ExtensionServiceCredential + nil, // 193: openshell.v1.SandboxSpec.EnvironmentEntry + nil, // 194: openshell.v1.SandboxTemplate.LabelsEntry + nil, // 195: openshell.v1.SandboxTemplate.AnnotationsEntry + nil, // 196: openshell.v1.SandboxTemplate.EnvironmentEntry + nil, // 197: openshell.v1.PlatformEvent.MetadataEntry + nil, // 198: openshell.v1.CreateSandboxRequest.LabelsEntry + nil, // 199: openshell.v1.CreateSandboxRequest.AnnotationsEntry + nil, // 200: openshell.v1.ExecSandboxRequest.EnvironmentEntry + nil, // 201: openshell.v1.SandboxLogLine.FieldsEntry + nil, // 202: openshell.v1.UpdateProviderRequest.CredentialExpiresAtMsEntry + nil, // 203: openshell.v1.StoredProviderCredentialRefreshState.MaterialEntry + nil, // 204: openshell.v1.StoredProviderCredentialRefreshState.AdditionalOutputKeysEntry + nil, // 205: openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry + nil, // 206: openshell.v1.ProviderProfile.AnnotationsEntry + nil, // 207: openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry + nil, // 208: openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpiresAtMsEntry + nil, // 209: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry + nil, // 210: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry + nil, // 211: openshell.v1.UpdateConfigRequest.AnnotationsEntry + nil, // 212: openshell.v1.UpdateConfigResponse.AnnotationsEntry + nil, // 213: openshell.v1.SandboxPolicyRevision.ProvenanceEntry + nil, // 214: openshell.v1.PolicyRevisionPayload.ProvenanceEntry + nil, // 215: openshell.v1.StoredPolicyRevision.ProvenanceEntry + nil, // 216: openshell.v1.CreateWorkspaceRequest.LabelsEntry + (*datamodelv1.ObjectMeta)(nil), // 217: openshell.datamodel.v1.ObjectMeta + (*sandboxv1.SandboxPolicy)(nil), // 218: openshell.sandbox.v1.SandboxPolicy + (*structpb.Struct)(nil), // 219: google.protobuf.Struct + (*datamodelv1.Provider)(nil), // 220: openshell.datamodel.v1.Provider + (*sandboxv1.NetworkEndpoint)(nil), // 221: openshell.sandbox.v1.NetworkEndpoint + (*sandboxv1.NetworkBinary)(nil), // 222: openshell.sandbox.v1.NetworkBinary + (*sandboxv1.SettingValue)(nil), // 223: openshell.sandbox.v1.SettingValue + (*sandboxv1.NetworkPolicyRule)(nil), // 224: openshell.sandbox.v1.NetworkPolicyRule + (*sandboxv1.L7DenyRule)(nil), // 225: openshell.sandbox.v1.L7DenyRule + (*sandboxv1.L7Rule)(nil), // 226: openshell.sandbox.v1.L7Rule + (*datamodelv1.Workspace)(nil), // 227: openshell.datamodel.v1.Workspace + (*sandboxv1.GetSandboxConfigRequest)(nil), // 228: openshell.sandbox.v1.GetSandboxConfigRequest + (*sandboxv1.GetGatewayConfigRequest)(nil), // 229: openshell.sandbox.v1.GetGatewayConfigRequest + (*sandboxv1.GetSandboxConfigResponse)(nil), // 230: openshell.sandbox.v1.GetSandboxConfigResponse + (*sandboxv1.GetGatewayConfigResponse)(nil), // 231: openshell.sandbox.v1.GetGatewayConfigResponse } var file_openshell_proto_depIdxs = []int32{ - 195, // 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 - 17, // 3: openshell.v1.GetGatewayInfoResponse.compute_drivers:type_name -> openshell.v1.ComputeDriverInfo - 18, // 4: openshell.v1.ComputeDriverInfo.capabilities:type_name -> openshell.v1.ComputeDriverCapabilities - 221, // 5: openshell.v1.Sandbox.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 20, // 6: openshell.v1.Sandbox.spec:type_name -> openshell.v1.SandboxSpec - 25, // 7: openshell.v1.Sandbox.status:type_name -> openshell.v1.SandboxStatus - 196, // 8: openshell.v1.SandboxSpec.environment:type_name -> openshell.v1.SandboxSpec.EnvironmentEntry - 24, // 9: openshell.v1.SandboxSpec.template:type_name -> openshell.v1.SandboxTemplate - 222, // 10: openshell.v1.SandboxSpec.policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 22, // 11: openshell.v1.SandboxSpec.resource_requirements:type_name -> openshell.v1.ResourceRequirements - 21, // 12: openshell.v1.SandboxSpec.main_process:type_name -> openshell.v1.MainProcessSpec - 197, // 13: openshell.v1.MainProcessSpec.environment:type_name -> openshell.v1.MainProcessSpec.EnvironmentEntry - 23, // 14: openshell.v1.ResourceRequirements.gpu:type_name -> openshell.v1.GpuResourceRequirements - 198, // 15: openshell.v1.SandboxTemplate.labels:type_name -> openshell.v1.SandboxTemplate.LabelsEntry - 199, // 16: openshell.v1.SandboxTemplate.annotations:type_name -> openshell.v1.SandboxTemplate.AnnotationsEntry - 200, // 17: openshell.v1.SandboxTemplate.environment:type_name -> openshell.v1.SandboxTemplate.EnvironmentEntry - 223, // 18: openshell.v1.SandboxTemplate.resources:type_name -> google.protobuf.Struct - 223, // 19: openshell.v1.SandboxTemplate.driver_config:type_name -> google.protobuf.Struct - 27, // 20: openshell.v1.SandboxStatus.conditions:type_name -> openshell.v1.SandboxCondition - 1, // 21: openshell.v1.SandboxStatus.phase:type_name -> openshell.v1.SandboxPhase - 26, // 22: openshell.v1.SandboxStatus.main_process:type_name -> openshell.v1.MainProcessStatus - 0, // 23: openshell.v1.MainProcessStatus.state:type_name -> openshell.v1.MainProcessState - 201, // 24: openshell.v1.PlatformEvent.metadata:type_name -> openshell.v1.PlatformEvent.MetadataEntry - 20, // 25: openshell.v1.CreateSandboxRequest.spec:type_name -> openshell.v1.SandboxSpec - 202, // 26: openshell.v1.CreateSandboxRequest.labels:type_name -> openshell.v1.CreateSandboxRequest.LabelsEntry - 203, // 27: openshell.v1.CreateSandboxRequest.annotations:type_name -> openshell.v1.CreateSandboxRequest.AnnotationsEntry - 19, // 28: openshell.v1.SandboxResponse.sandbox:type_name -> openshell.v1.Sandbox - 19, // 29: openshell.v1.ListSandboxesResponse.sandboxes:type_name -> openshell.v1.Sandbox - 224, // 30: openshell.v1.ListSandboxProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider - 19, // 31: openshell.v1.AttachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox - 19, // 32: openshell.v1.DetachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox - 53, // 33: openshell.v1.ListServicesResponse.services:type_name -> openshell.v1.ServiceEndpointResponse - 221, // 34: openshell.v1.ServiceEndpoint.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 52, // 35: openshell.v1.ServiceEndpointResponse.endpoint:type_name -> openshell.v1.ServiceEndpoint - 204, // 36: openshell.v1.ExecSandboxRequest.environment:type_name -> openshell.v1.ExecSandboxRequest.EnvironmentEntry - 57, // 37: openshell.v1.ExecSandboxEvent.stdout:type_name -> openshell.v1.ExecSandboxStdout - 58, // 38: openshell.v1.ExecSandboxEvent.stderr:type_name -> openshell.v1.ExecSandboxStderr - 59, // 39: openshell.v1.ExecSandboxEvent.exit:type_name -> openshell.v1.ExecSandboxExit - 145, // 40: openshell.v1.TcpForwardInit.ssh:type_name -> openshell.v1.SshRelayTarget - 146, // 41: openshell.v1.TcpForwardInit.tcp:type_name -> openshell.v1.TcpRelayTarget - 61, // 42: openshell.v1.TcpForwardFrame.init:type_name -> openshell.v1.TcpForwardInit - 56, // 43: openshell.v1.ExecSandboxInput.start:type_name -> openshell.v1.ExecSandboxRequest - 64, // 44: openshell.v1.ExecSandboxInput.resize:type_name -> openshell.v1.ExecSandboxWindowResize - 221, // 45: openshell.v1.SshSession.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 19, // 46: openshell.v1.SandboxStreamEvent.sandbox:type_name -> openshell.v1.Sandbox - 68, // 47: openshell.v1.SandboxStreamEvent.log:type_name -> openshell.v1.SandboxLogLine - 28, // 48: openshell.v1.SandboxStreamEvent.event:type_name -> openshell.v1.PlatformEvent - 69, // 49: openshell.v1.SandboxStreamEvent.warning:type_name -> openshell.v1.SandboxStreamWarning - 156, // 50: openshell.v1.SandboxStreamEvent.draft_policy_update:type_name -> openshell.v1.DraftPolicyUpdate - 205, // 51: openshell.v1.SandboxLogLine.fields:type_name -> openshell.v1.SandboxLogLine.FieldsEntry - 224, // 52: openshell.v1.CreateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider - 224, // 53: openshell.v1.UpdateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider - 206, // 54: openshell.v1.UpdateProviderRequest.credential_expires_at_ms:type_name -> openshell.v1.UpdateProviderRequest.CredentialExpiresAtMsEntry - 224, // 55: openshell.v1.ProviderResponse.provider:type_name -> openshell.datamodel.v1.Provider - 224, // 56: openshell.v1.ListProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider - 98, // 57: openshell.v1.ProviderProfileImportItem.profile:type_name -> openshell.v1.ProviderProfile - 81, // 58: openshell.v1.ProviderCredentialTokenGrant.audience_overrides:type_name -> openshell.v1.ProviderCredentialTokenGrantAudienceOverride - 86, // 59: openshell.v1.ProviderProfileCredential.refresh:type_name -> openshell.v1.ProviderCredentialRefresh - 82, // 60: openshell.v1.ProviderProfileCredential.token_grant:type_name -> openshell.v1.ProviderCredentialTokenGrant - 2, // 61: openshell.v1.ProviderCredentialRefresh.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 84, // 62: openshell.v1.ProviderCredentialRefresh.material:type_name -> openshell.v1.ProviderCredentialRefreshMaterial - 85, // 63: openshell.v1.ProviderCredentialRefresh.additional_outputs:type_name -> openshell.v1.ProviderCredentialRefreshOutput - 2, // 64: openshell.v1.ProviderCredentialRefreshStatus.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 221, // 65: openshell.v1.StoredProviderCredentialRefreshState.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 2, // 66: openshell.v1.StoredProviderCredentialRefreshState.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 207, // 67: openshell.v1.StoredProviderCredentialRefreshState.material:type_name -> openshell.v1.StoredProviderCredentialRefreshState.MaterialEntry - 208, // 68: openshell.v1.StoredProviderCredentialRefreshState.additional_output_keys:type_name -> openshell.v1.StoredProviderCredentialRefreshState.AdditionalOutputKeysEntry - 87, // 69: openshell.v1.GetProviderRefreshStatusResponse.credentials:type_name -> openshell.v1.ProviderCredentialRefreshStatus - 2, // 70: openshell.v1.ConfigureProviderRefreshRequest.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy - 209, // 71: openshell.v1.ConfigureProviderRefreshRequest.material:type_name -> openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry - 87, // 72: openshell.v1.ConfigureProviderRefreshResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus - 87, // 73: openshell.v1.RotateProviderCredentialResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus - 3, // 74: openshell.v1.ProviderProfile.category:type_name -> openshell.v1.ProviderProfileCategory - 83, // 75: openshell.v1.ProviderProfile.credentials:type_name -> openshell.v1.ProviderProfileCredential - 225, // 76: openshell.v1.ProviderProfile.endpoints:type_name -> openshell.sandbox.v1.NetworkEndpoint - 226, // 77: openshell.v1.ProviderProfile.binaries:type_name -> openshell.sandbox.v1.NetworkBinary - 88, // 78: openshell.v1.ProviderProfile.discovery:type_name -> openshell.v1.ProviderProfileDiscovery - 210, // 79: openshell.v1.ProviderProfile.annotations:type_name -> openshell.v1.ProviderProfile.AnnotationsEntry - 221, // 80: openshell.v1.StoredProviderProfile.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 98, // 81: openshell.v1.StoredProviderProfile.profile:type_name -> openshell.v1.ProviderProfile - 98, // 82: openshell.v1.ProviderProfileResponse.profile:type_name -> openshell.v1.ProviderProfile - 98, // 83: openshell.v1.ListProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile - 79, // 84: openshell.v1.ImportProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem - 80, // 85: openshell.v1.ImportProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic - 98, // 86: openshell.v1.ImportProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile - 79, // 87: openshell.v1.UpdateProviderProfilesRequest.profile:type_name -> openshell.v1.ProviderProfileImportItem - 80, // 88: openshell.v1.UpdateProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic - 98, // 89: openshell.v1.UpdateProviderProfilesResponse.profile:type_name -> openshell.v1.ProviderProfile - 79, // 90: openshell.v1.LintProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem - 80, // 91: openshell.v1.LintProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic - 112, // 92: openshell.v1.StaticCredentialBinding.endpoints:type_name -> openshell.v1.StaticCredentialEndpointBinding - 211, // 93: openshell.v1.GetSandboxProviderEnvironmentResponse.environment:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry - 212, // 94: openshell.v1.GetSandboxProviderEnvironmentResponse.credential_expires_at_ms:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpiresAtMsEntry - 213, // 95: openshell.v1.GetSandboxProviderEnvironmentResponse.dynamic_credentials:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry - 214, // 96: openshell.v1.GetSandboxProviderEnvironmentResponse.static_credential_bindings:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry - 222, // 97: openshell.v1.UpdateConfigRequest.policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 227, // 98: openshell.v1.UpdateConfigRequest.setting_value:type_name -> openshell.sandbox.v1.SettingValue - 116, // 99: openshell.v1.UpdateConfigRequest.merge_operations:type_name -> openshell.v1.PolicyMergeOperation - 215, // 100: openshell.v1.UpdateConfigRequest.annotations:type_name -> openshell.v1.UpdateConfigRequest.AnnotationsEntry - 117, // 101: openshell.v1.PolicyMergeOperation.add_rule:type_name -> openshell.v1.AddNetworkRule - 118, // 102: openshell.v1.PolicyMergeOperation.remove_endpoint:type_name -> openshell.v1.RemoveNetworkEndpoint - 119, // 103: openshell.v1.PolicyMergeOperation.remove_rule:type_name -> openshell.v1.RemoveNetworkRule - 120, // 104: openshell.v1.PolicyMergeOperation.add_deny_rules:type_name -> openshell.v1.AddDenyRules - 121, // 105: openshell.v1.PolicyMergeOperation.add_allow_rules:type_name -> openshell.v1.AddAllowRules - 122, // 106: openshell.v1.PolicyMergeOperation.remove_binary:type_name -> openshell.v1.RemoveNetworkBinary - 228, // 107: openshell.v1.AddNetworkRule.rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 229, // 108: openshell.v1.AddDenyRules.deny_rules:type_name -> openshell.sandbox.v1.L7DenyRule - 230, // 109: openshell.v1.AddAllowRules.rules:type_name -> openshell.sandbox.v1.L7Rule - 216, // 110: openshell.v1.UpdateConfigResponse.annotations:type_name -> openshell.v1.UpdateConfigResponse.AnnotationsEntry - 130, // 111: openshell.v1.GetSandboxPolicyStatusResponse.revision:type_name -> openshell.v1.SandboxPolicyRevision - 130, // 112: openshell.v1.ListSandboxPoliciesResponse.revisions:type_name -> openshell.v1.SandboxPolicyRevision - 4, // 113: openshell.v1.ReportPolicyStatusRequest.status:type_name -> openshell.v1.PolicyStatus - 4, // 114: openshell.v1.SandboxPolicyRevision.status:type_name -> openshell.v1.PolicyStatus - 222, // 115: openshell.v1.SandboxPolicyRevision.policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 217, // 116: openshell.v1.SandboxPolicyRevision.provenance:type_name -> openshell.v1.SandboxPolicyRevision.ProvenanceEntry - 68, // 117: openshell.v1.PushSandboxLogsRequest.logs:type_name -> openshell.v1.SandboxLogLine - 68, // 118: openshell.v1.GetSandboxLogsResponse.logs:type_name -> openshell.v1.SandboxLogLine - 137, // 119: openshell.v1.SupervisorMessage.hello:type_name -> openshell.v1.SupervisorHello - 140, // 120: openshell.v1.SupervisorMessage.heartbeat:type_name -> openshell.v1.SupervisorHeartbeat - 149, // 121: openshell.v1.SupervisorMessage.relay_open_result:type_name -> openshell.v1.RelayOpenResult - 150, // 122: openshell.v1.SupervisorMessage.relay_close:type_name -> openshell.v1.RelayClose - 142, // 123: openshell.v1.SupervisorMessage.main_process_exit:type_name -> openshell.v1.MainProcessExit - 138, // 124: openshell.v1.GatewayMessage.session_accepted:type_name -> openshell.v1.SessionAccepted - 139, // 125: openshell.v1.GatewayMessage.session_rejected:type_name -> openshell.v1.SessionRejected - 141, // 126: openshell.v1.GatewayMessage.heartbeat:type_name -> openshell.v1.GatewayHeartbeat - 144, // 127: openshell.v1.GatewayMessage.relay_open:type_name -> openshell.v1.RelayOpen - 150, // 128: openshell.v1.GatewayMessage.relay_close:type_name -> openshell.v1.RelayClose - 143, // 129: openshell.v1.GatewayMessage.main_process_exit_ack:type_name -> openshell.v1.MainProcessExitAck - 145, // 130: openshell.v1.RelayOpen.ssh:type_name -> openshell.v1.SshRelayTarget - 146, // 131: openshell.v1.RelayOpen.tcp:type_name -> openshell.v1.TcpRelayTarget - 147, // 132: openshell.v1.RelayFrame.init:type_name -> openshell.v1.RelayInit - 151, // 133: openshell.v1.DenialSummary.l7_request_samples:type_name -> openshell.v1.L7RequestSample - 153, // 134: openshell.v1.NetworkActivitySummary.denials_by_group:type_name -> openshell.v1.DenialGroupCount - 228, // 135: openshell.v1.PolicyChunk.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 152, // 136: openshell.v1.SubmitPolicyAnalysisRequest.summaries:type_name -> openshell.v1.DenialSummary - 155, // 137: openshell.v1.SubmitPolicyAnalysisRequest.proposed_chunks:type_name -> openshell.v1.PolicyChunk - 154, // 138: openshell.v1.SubmitPolicyAnalysisRequest.network_activity_summaries:type_name -> openshell.v1.NetworkActivitySummary - 155, // 139: openshell.v1.GetDraftPolicyResponse.chunks:type_name -> openshell.v1.PolicyChunk - 228, // 140: openshell.v1.EditDraftChunkRequest.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 174, // 141: openshell.v1.GetDraftHistoryResponse.entries:type_name -> openshell.v1.DraftHistoryEntry - 222, // 142: openshell.v1.PolicyRevisionPayload.policy:type_name -> openshell.sandbox.v1.SandboxPolicy - 218, // 143: openshell.v1.PolicyRevisionPayload.provenance:type_name -> openshell.v1.PolicyRevisionPayload.ProvenanceEntry - 228, // 144: openshell.v1.DraftChunkPayload.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule - 219, // 145: openshell.v1.StoredPolicyRevision.provenance:type_name -> openshell.v1.StoredPolicyRevision.ProvenanceEntry - 220, // 146: openshell.v1.CreateWorkspaceRequest.labels:type_name -> openshell.v1.CreateWorkspaceRequest.LabelsEntry - 231, // 147: openshell.v1.CreateWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace - 231, // 148: openshell.v1.GetWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace - 231, // 149: openshell.v1.ListWorkspacesResponse.workspaces:type_name -> openshell.datamodel.v1.Workspace - 221, // 150: openshell.v1.WorkspaceMember.metadata:type_name -> openshell.datamodel.v1.ObjectMeta - 6, // 151: openshell.v1.WorkspaceMember.role:type_name -> openshell.v1.WorkspaceRole - 6, // 152: openshell.v1.AddWorkspaceMemberRequest.role:type_name -> openshell.v1.WorkspaceRole - 188, // 153: openshell.v1.AddWorkspaceMemberResponse.member:type_name -> openshell.v1.WorkspaceMember - 188, // 154: openshell.v1.ListWorkspaceMembersResponse.members:type_name -> openshell.v1.WorkspaceMember - 83, // 155: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry.value:type_name -> openshell.v1.ProviderProfileCredential - 113, // 156: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry.value:type_name -> openshell.v1.StaticCredentialBinding - 11, // 157: openshell.v1.OpenShell.Health:input_type -> openshell.v1.HealthRequest - 13, // 158: openshell.v1.OpenShell.GetCurrentUser:input_type -> openshell.v1.GetCurrentUserRequest - 15, // 159: openshell.v1.OpenShell.GetGatewayInfo:input_type -> openshell.v1.GetGatewayInfoRequest - 29, // 160: openshell.v1.OpenShell.CreateSandbox:input_type -> openshell.v1.CreateSandboxRequest - 30, // 161: openshell.v1.OpenShell.GetSandbox:input_type -> openshell.v1.GetSandboxRequest - 31, // 162: openshell.v1.OpenShell.ListSandboxes:input_type -> openshell.v1.ListSandboxesRequest - 32, // 163: openshell.v1.OpenShell.ListSandboxProviders:input_type -> openshell.v1.ListSandboxProvidersRequest - 33, // 164: openshell.v1.OpenShell.AttachSandboxProvider:input_type -> openshell.v1.AttachSandboxProviderRequest - 34, // 165: openshell.v1.OpenShell.DetachSandboxProvider:input_type -> openshell.v1.DetachSandboxProviderRequest - 35, // 166: openshell.v1.OpenShell.DeleteSandbox:input_type -> openshell.v1.DeleteSandboxRequest - 36, // 167: openshell.v1.OpenShell.StopSandbox:input_type -> openshell.v1.StopSandboxRequest - 37, // 168: openshell.v1.OpenShell.StartSandbox:input_type -> openshell.v1.StartSandboxRequest - 44, // 169: openshell.v1.OpenShell.CreateSshSession:input_type -> openshell.v1.CreateSshSessionRequest - 46, // 170: openshell.v1.OpenShell.ExposeService:input_type -> openshell.v1.ExposeServiceRequest - 47, // 171: openshell.v1.OpenShell.GetService:input_type -> openshell.v1.GetServiceRequest - 48, // 172: openshell.v1.OpenShell.ListServices:input_type -> openshell.v1.ListServicesRequest - 50, // 173: openshell.v1.OpenShell.DeleteService:input_type -> openshell.v1.DeleteServiceRequest - 54, // 174: openshell.v1.OpenShell.RevokeSshSession:input_type -> openshell.v1.RevokeSshSessionRequest - 56, // 175: openshell.v1.OpenShell.ExecSandbox:input_type -> openshell.v1.ExecSandboxRequest - 62, // 176: openshell.v1.OpenShell.ForwardTcp:input_type -> openshell.v1.TcpForwardFrame - 63, // 177: openshell.v1.OpenShell.ExecSandboxInteractive:input_type -> openshell.v1.ExecSandboxInput - 70, // 178: openshell.v1.OpenShell.CreateProvider:input_type -> openshell.v1.CreateProviderRequest - 71, // 179: openshell.v1.OpenShell.GetProvider:input_type -> openshell.v1.GetProviderRequest - 72, // 180: openshell.v1.OpenShell.ListProviders:input_type -> openshell.v1.ListProvidersRequest - 77, // 181: openshell.v1.OpenShell.ListProviderProfiles:input_type -> openshell.v1.ListProviderProfilesRequest - 78, // 182: openshell.v1.OpenShell.GetProviderProfile:input_type -> openshell.v1.GetProviderProfileRequest - 102, // 183: openshell.v1.OpenShell.ImportProviderProfiles:input_type -> openshell.v1.ImportProviderProfilesRequest - 104, // 184: openshell.v1.OpenShell.UpdateProviderProfiles:input_type -> openshell.v1.UpdateProviderProfilesRequest - 106, // 185: openshell.v1.OpenShell.LintProviderProfiles:input_type -> openshell.v1.LintProviderProfilesRequest - 73, // 186: openshell.v1.OpenShell.UpdateProvider:input_type -> openshell.v1.UpdateProviderRequest - 90, // 187: openshell.v1.OpenShell.GetProviderRefreshStatus:input_type -> openshell.v1.GetProviderRefreshStatusRequest - 92, // 188: openshell.v1.OpenShell.ConfigureProviderRefresh:input_type -> openshell.v1.ConfigureProviderRefreshRequest - 94, // 189: openshell.v1.OpenShell.RotateProviderCredential:input_type -> openshell.v1.RotateProviderCredentialRequest - 96, // 190: openshell.v1.OpenShell.DeleteProviderRefresh:input_type -> openshell.v1.DeleteProviderRefreshRequest - 74, // 191: openshell.v1.OpenShell.DeleteProvider:input_type -> openshell.v1.DeleteProviderRequest - 109, // 192: openshell.v1.OpenShell.DeleteProviderProfile:input_type -> openshell.v1.DeleteProviderProfileRequest - 232, // 193: openshell.v1.OpenShell.GetSandboxConfig:input_type -> openshell.sandbox.v1.GetSandboxConfigRequest - 233, // 194: openshell.v1.OpenShell.GetGatewayConfig:input_type -> openshell.sandbox.v1.GetGatewayConfigRequest - 115, // 195: openshell.v1.OpenShell.UpdateConfig:input_type -> openshell.v1.UpdateConfigRequest - 124, // 196: openshell.v1.OpenShell.GetSandboxPolicyStatus:input_type -> openshell.v1.GetSandboxPolicyStatusRequest - 126, // 197: openshell.v1.OpenShell.ListSandboxPolicies:input_type -> openshell.v1.ListSandboxPoliciesRequest - 128, // 198: openshell.v1.OpenShell.ReportPolicyStatus:input_type -> openshell.v1.ReportPolicyStatusRequest - 111, // 199: openshell.v1.OpenShell.GetSandboxProviderEnvironment:input_type -> openshell.v1.GetSandboxProviderEnvironmentRequest - 131, // 200: openshell.v1.OpenShell.GetSandboxLogs:input_type -> openshell.v1.GetSandboxLogsRequest - 132, // 201: openshell.v1.OpenShell.PushSandboxLogs:input_type -> openshell.v1.PushSandboxLogsRequest - 135, // 202: openshell.v1.OpenShell.ConnectSupervisor:input_type -> openshell.v1.SupervisorMessage - 148, // 203: openshell.v1.OpenShell.RelayStream:input_type -> openshell.v1.RelayFrame - 66, // 204: openshell.v1.OpenShell.WatchSandbox:input_type -> openshell.v1.WatchSandboxRequest - 157, // 205: openshell.v1.OpenShell.SubmitPolicyAnalysis:input_type -> openshell.v1.SubmitPolicyAnalysisRequest - 159, // 206: openshell.v1.OpenShell.GetDraftPolicy:input_type -> openshell.v1.GetDraftPolicyRequest - 161, // 207: openshell.v1.OpenShell.ApproveDraftChunk:input_type -> openshell.v1.ApproveDraftChunkRequest - 163, // 208: openshell.v1.OpenShell.RejectDraftChunk:input_type -> openshell.v1.RejectDraftChunkRequest - 165, // 209: openshell.v1.OpenShell.ApproveAllDraftChunks:input_type -> openshell.v1.ApproveAllDraftChunksRequest - 167, // 210: openshell.v1.OpenShell.EditDraftChunk:input_type -> openshell.v1.EditDraftChunkRequest - 169, // 211: openshell.v1.OpenShell.UndoDraftChunk:input_type -> openshell.v1.UndoDraftChunkRequest - 171, // 212: openshell.v1.OpenShell.ClearDraftChunks:input_type -> openshell.v1.ClearDraftChunksRequest - 173, // 213: openshell.v1.OpenShell.GetDraftHistory:input_type -> openshell.v1.GetDraftHistoryRequest - 7, // 214: openshell.v1.OpenShell.IssueSandboxToken:input_type -> openshell.v1.IssueSandboxTokenRequest - 9, // 215: openshell.v1.OpenShell.RefreshSandboxToken:input_type -> openshell.v1.RefreshSandboxTokenRequest - 180, // 216: openshell.v1.OpenShell.CreateWorkspace:input_type -> openshell.v1.CreateWorkspaceRequest - 182, // 217: openshell.v1.OpenShell.GetWorkspace:input_type -> openshell.v1.GetWorkspaceRequest - 184, // 218: openshell.v1.OpenShell.ListWorkspaces:input_type -> openshell.v1.ListWorkspacesRequest - 186, // 219: openshell.v1.OpenShell.DeleteWorkspace:input_type -> openshell.v1.DeleteWorkspaceRequest - 189, // 220: openshell.v1.OpenShell.AddWorkspaceMember:input_type -> openshell.v1.AddWorkspaceMemberRequest - 191, // 221: openshell.v1.OpenShell.RemoveWorkspaceMember:input_type -> openshell.v1.RemoveWorkspaceMemberRequest - 193, // 222: openshell.v1.OpenShell.ListWorkspaceMembers:input_type -> openshell.v1.ListWorkspaceMembersRequest - 12, // 223: openshell.v1.OpenShell.Health:output_type -> openshell.v1.HealthResponse - 14, // 224: openshell.v1.OpenShell.GetCurrentUser:output_type -> openshell.v1.GetCurrentUserResponse - 16, // 225: openshell.v1.OpenShell.GetGatewayInfo:output_type -> openshell.v1.GetGatewayInfoResponse - 38, // 226: openshell.v1.OpenShell.CreateSandbox:output_type -> openshell.v1.SandboxResponse - 38, // 227: openshell.v1.OpenShell.GetSandbox:output_type -> openshell.v1.SandboxResponse - 39, // 228: openshell.v1.OpenShell.ListSandboxes:output_type -> openshell.v1.ListSandboxesResponse - 40, // 229: openshell.v1.OpenShell.ListSandboxProviders:output_type -> openshell.v1.ListSandboxProvidersResponse - 41, // 230: openshell.v1.OpenShell.AttachSandboxProvider:output_type -> openshell.v1.AttachSandboxProviderResponse - 42, // 231: openshell.v1.OpenShell.DetachSandboxProvider:output_type -> openshell.v1.DetachSandboxProviderResponse - 43, // 232: openshell.v1.OpenShell.DeleteSandbox:output_type -> openshell.v1.DeleteSandboxResponse - 38, // 233: openshell.v1.OpenShell.StopSandbox:output_type -> openshell.v1.SandboxResponse - 38, // 234: openshell.v1.OpenShell.StartSandbox:output_type -> openshell.v1.SandboxResponse - 45, // 235: openshell.v1.OpenShell.CreateSshSession:output_type -> openshell.v1.CreateSshSessionResponse - 53, // 236: openshell.v1.OpenShell.ExposeService:output_type -> openshell.v1.ServiceEndpointResponse - 53, // 237: openshell.v1.OpenShell.GetService:output_type -> openshell.v1.ServiceEndpointResponse - 49, // 238: openshell.v1.OpenShell.ListServices:output_type -> openshell.v1.ListServicesResponse - 51, // 239: openshell.v1.OpenShell.DeleteService:output_type -> openshell.v1.DeleteServiceResponse - 55, // 240: openshell.v1.OpenShell.RevokeSshSession:output_type -> openshell.v1.RevokeSshSessionResponse - 60, // 241: openshell.v1.OpenShell.ExecSandbox:output_type -> openshell.v1.ExecSandboxEvent - 62, // 242: openshell.v1.OpenShell.ForwardTcp:output_type -> openshell.v1.TcpForwardFrame - 60, // 243: openshell.v1.OpenShell.ExecSandboxInteractive:output_type -> openshell.v1.ExecSandboxEvent - 75, // 244: openshell.v1.OpenShell.CreateProvider:output_type -> openshell.v1.ProviderResponse - 75, // 245: openshell.v1.OpenShell.GetProvider:output_type -> openshell.v1.ProviderResponse - 76, // 246: openshell.v1.OpenShell.ListProviders:output_type -> openshell.v1.ListProvidersResponse - 101, // 247: openshell.v1.OpenShell.ListProviderProfiles:output_type -> openshell.v1.ListProviderProfilesResponse - 100, // 248: openshell.v1.OpenShell.GetProviderProfile:output_type -> openshell.v1.ProviderProfileResponse - 103, // 249: openshell.v1.OpenShell.ImportProviderProfiles:output_type -> openshell.v1.ImportProviderProfilesResponse - 105, // 250: openshell.v1.OpenShell.UpdateProviderProfiles:output_type -> openshell.v1.UpdateProviderProfilesResponse - 107, // 251: openshell.v1.OpenShell.LintProviderProfiles:output_type -> openshell.v1.LintProviderProfilesResponse - 75, // 252: openshell.v1.OpenShell.UpdateProvider:output_type -> openshell.v1.ProviderResponse - 91, // 253: openshell.v1.OpenShell.GetProviderRefreshStatus:output_type -> openshell.v1.GetProviderRefreshStatusResponse - 93, // 254: openshell.v1.OpenShell.ConfigureProviderRefresh:output_type -> openshell.v1.ConfigureProviderRefreshResponse - 95, // 255: openshell.v1.OpenShell.RotateProviderCredential:output_type -> openshell.v1.RotateProviderCredentialResponse - 97, // 256: openshell.v1.OpenShell.DeleteProviderRefresh:output_type -> openshell.v1.DeleteProviderRefreshResponse - 108, // 257: openshell.v1.OpenShell.DeleteProvider:output_type -> openshell.v1.DeleteProviderResponse - 110, // 258: openshell.v1.OpenShell.DeleteProviderProfile:output_type -> openshell.v1.DeleteProviderProfileResponse - 234, // 259: openshell.v1.OpenShell.GetSandboxConfig:output_type -> openshell.sandbox.v1.GetSandboxConfigResponse - 235, // 260: openshell.v1.OpenShell.GetGatewayConfig:output_type -> openshell.sandbox.v1.GetGatewayConfigResponse - 123, // 261: openshell.v1.OpenShell.UpdateConfig:output_type -> openshell.v1.UpdateConfigResponse - 125, // 262: openshell.v1.OpenShell.GetSandboxPolicyStatus:output_type -> openshell.v1.GetSandboxPolicyStatusResponse - 127, // 263: openshell.v1.OpenShell.ListSandboxPolicies:output_type -> openshell.v1.ListSandboxPoliciesResponse - 129, // 264: openshell.v1.OpenShell.ReportPolicyStatus:output_type -> openshell.v1.ReportPolicyStatusResponse - 114, // 265: openshell.v1.OpenShell.GetSandboxProviderEnvironment:output_type -> openshell.v1.GetSandboxProviderEnvironmentResponse - 134, // 266: openshell.v1.OpenShell.GetSandboxLogs:output_type -> openshell.v1.GetSandboxLogsResponse - 133, // 267: openshell.v1.OpenShell.PushSandboxLogs:output_type -> openshell.v1.PushSandboxLogsResponse - 136, // 268: openshell.v1.OpenShell.ConnectSupervisor:output_type -> openshell.v1.GatewayMessage - 148, // 269: openshell.v1.OpenShell.RelayStream:output_type -> openshell.v1.RelayFrame - 67, // 270: openshell.v1.OpenShell.WatchSandbox:output_type -> openshell.v1.SandboxStreamEvent - 158, // 271: openshell.v1.OpenShell.SubmitPolicyAnalysis:output_type -> openshell.v1.SubmitPolicyAnalysisResponse - 160, // 272: openshell.v1.OpenShell.GetDraftPolicy:output_type -> openshell.v1.GetDraftPolicyResponse - 162, // 273: openshell.v1.OpenShell.ApproveDraftChunk:output_type -> openshell.v1.ApproveDraftChunkResponse - 164, // 274: openshell.v1.OpenShell.RejectDraftChunk:output_type -> openshell.v1.RejectDraftChunkResponse - 166, // 275: openshell.v1.OpenShell.ApproveAllDraftChunks:output_type -> openshell.v1.ApproveAllDraftChunksResponse - 168, // 276: openshell.v1.OpenShell.EditDraftChunk:output_type -> openshell.v1.EditDraftChunkResponse - 170, // 277: openshell.v1.OpenShell.UndoDraftChunk:output_type -> openshell.v1.UndoDraftChunkResponse - 172, // 278: openshell.v1.OpenShell.ClearDraftChunks:output_type -> openshell.v1.ClearDraftChunksResponse - 175, // 279: openshell.v1.OpenShell.GetDraftHistory:output_type -> openshell.v1.GetDraftHistoryResponse - 8, // 280: openshell.v1.OpenShell.IssueSandboxToken:output_type -> openshell.v1.IssueSandboxTokenResponse - 10, // 281: openshell.v1.OpenShell.RefreshSandboxToken:output_type -> openshell.v1.RefreshSandboxTokenResponse - 181, // 282: openshell.v1.OpenShell.CreateWorkspace:output_type -> openshell.v1.CreateWorkspaceResponse - 183, // 283: openshell.v1.OpenShell.GetWorkspace:output_type -> openshell.v1.GetWorkspaceResponse - 185, // 284: openshell.v1.OpenShell.ListWorkspaces:output_type -> openshell.v1.ListWorkspacesResponse - 187, // 285: openshell.v1.OpenShell.DeleteWorkspace:output_type -> openshell.v1.DeleteWorkspaceResponse - 190, // 286: openshell.v1.OpenShell.AddWorkspaceMember:output_type -> openshell.v1.AddWorkspaceMemberResponse - 192, // 287: openshell.v1.OpenShell.RemoveWorkspaceMember:output_type -> openshell.v1.RemoveWorkspaceMemberResponse - 194, // 288: openshell.v1.OpenShell.ListWorkspaceMembers:output_type -> openshell.v1.ListWorkspaceMembersResponse - 223, // [223:289] is the sub-list for method output_type - 157, // [157:223] is the sub-list for method input_type - 157, // [157:157] is the sub-list for extension type_name - 157, // [157:157] is the sub-list for extension extendee - 0, // [0:157] is the sub-list for field type_name + 192, // 0: openshell.v1.RefreshSandboxTokenResponse.extension_credentials:type_name -> openshell.v1.ExtensionServiceCredential + 4, // 1: openshell.v1.HealthResponse.status:type_name -> openshell.v1.ServiceStatus + 4, // 2: openshell.v1.GetGatewayInfoResponse.status:type_name -> openshell.v1.ServiceStatus + 16, // 3: openshell.v1.GetGatewayInfoResponse.compute_drivers:type_name -> openshell.v1.ComputeDriverInfo + 17, // 4: openshell.v1.ComputeDriverInfo.capabilities:type_name -> openshell.v1.ComputeDriverCapabilities + 217, // 5: openshell.v1.Sandbox.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 19, // 6: openshell.v1.Sandbox.spec:type_name -> openshell.v1.SandboxSpec + 23, // 7: openshell.v1.Sandbox.status:type_name -> openshell.v1.SandboxStatus + 193, // 8: openshell.v1.SandboxSpec.environment:type_name -> openshell.v1.SandboxSpec.EnvironmentEntry + 22, // 9: openshell.v1.SandboxSpec.template:type_name -> openshell.v1.SandboxTemplate + 218, // 10: openshell.v1.SandboxSpec.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 20, // 11: openshell.v1.SandboxSpec.resource_requirements:type_name -> openshell.v1.ResourceRequirements + 21, // 12: openshell.v1.ResourceRequirements.gpu:type_name -> openshell.v1.GpuResourceRequirements + 194, // 13: openshell.v1.SandboxTemplate.labels:type_name -> openshell.v1.SandboxTemplate.LabelsEntry + 195, // 14: openshell.v1.SandboxTemplate.annotations:type_name -> openshell.v1.SandboxTemplate.AnnotationsEntry + 196, // 15: openshell.v1.SandboxTemplate.environment:type_name -> openshell.v1.SandboxTemplate.EnvironmentEntry + 219, // 16: openshell.v1.SandboxTemplate.resources:type_name -> google.protobuf.Struct + 219, // 17: openshell.v1.SandboxTemplate.driver_config:type_name -> google.protobuf.Struct + 24, // 18: openshell.v1.SandboxStatus.conditions:type_name -> openshell.v1.SandboxCondition + 0, // 19: openshell.v1.SandboxStatus.phase:type_name -> openshell.v1.SandboxPhase + 197, // 20: openshell.v1.PlatformEvent.metadata:type_name -> openshell.v1.PlatformEvent.MetadataEntry + 19, // 21: openshell.v1.CreateSandboxRequest.spec:type_name -> openshell.v1.SandboxSpec + 198, // 22: openshell.v1.CreateSandboxRequest.labels:type_name -> openshell.v1.CreateSandboxRequest.LabelsEntry + 199, // 23: openshell.v1.CreateSandboxRequest.annotations:type_name -> openshell.v1.CreateSandboxRequest.AnnotationsEntry + 18, // 24: openshell.v1.SandboxResponse.sandbox:type_name -> openshell.v1.Sandbox + 18, // 25: openshell.v1.ListSandboxesResponse.sandboxes:type_name -> openshell.v1.Sandbox + 220, // 26: openshell.v1.ListSandboxProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider + 18, // 27: openshell.v1.AttachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox + 18, // 28: openshell.v1.DetachSandboxProviderResponse.sandbox:type_name -> openshell.v1.Sandbox + 50, // 29: openshell.v1.ListServicesResponse.services:type_name -> openshell.v1.ServiceEndpointResponse + 217, // 30: openshell.v1.ServiceEndpoint.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 49, // 31: openshell.v1.ServiceEndpointResponse.endpoint:type_name -> openshell.v1.ServiceEndpoint + 200, // 32: openshell.v1.ExecSandboxRequest.environment:type_name -> openshell.v1.ExecSandboxRequest.EnvironmentEntry + 54, // 33: openshell.v1.ExecSandboxEvent.stdout:type_name -> openshell.v1.ExecSandboxStdout + 55, // 34: openshell.v1.ExecSandboxEvent.stderr:type_name -> openshell.v1.ExecSandboxStderr + 56, // 35: openshell.v1.ExecSandboxEvent.exit:type_name -> openshell.v1.ExecSandboxExit + 142, // 36: openshell.v1.TcpForwardInit.ssh:type_name -> openshell.v1.SshRelayTarget + 143, // 37: openshell.v1.TcpForwardInit.tcp:type_name -> openshell.v1.TcpRelayTarget + 58, // 38: openshell.v1.TcpForwardFrame.init:type_name -> openshell.v1.TcpForwardInit + 53, // 39: openshell.v1.ExecSandboxInput.start:type_name -> openshell.v1.ExecSandboxRequest + 61, // 40: openshell.v1.ExecSandboxInput.resize:type_name -> openshell.v1.ExecSandboxWindowResize + 217, // 41: openshell.v1.SshSession.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 18, // 42: openshell.v1.SandboxStreamEvent.sandbox:type_name -> openshell.v1.Sandbox + 65, // 43: openshell.v1.SandboxStreamEvent.log:type_name -> openshell.v1.SandboxLogLine + 25, // 44: openshell.v1.SandboxStreamEvent.event:type_name -> openshell.v1.PlatformEvent + 66, // 45: openshell.v1.SandboxStreamEvent.warning:type_name -> openshell.v1.SandboxStreamWarning + 153, // 46: openshell.v1.SandboxStreamEvent.draft_policy_update:type_name -> openshell.v1.DraftPolicyUpdate + 201, // 47: openshell.v1.SandboxLogLine.fields:type_name -> openshell.v1.SandboxLogLine.FieldsEntry + 220, // 48: openshell.v1.CreateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider + 220, // 49: openshell.v1.UpdateProviderRequest.provider:type_name -> openshell.datamodel.v1.Provider + 202, // 50: openshell.v1.UpdateProviderRequest.credential_expires_at_ms:type_name -> openshell.v1.UpdateProviderRequest.CredentialExpiresAtMsEntry + 220, // 51: openshell.v1.ProviderResponse.provider:type_name -> openshell.datamodel.v1.Provider + 220, // 52: openshell.v1.ListProvidersResponse.providers:type_name -> openshell.datamodel.v1.Provider + 95, // 53: openshell.v1.ProviderProfileImportItem.profile:type_name -> openshell.v1.ProviderProfile + 78, // 54: openshell.v1.ProviderCredentialTokenGrant.audience_overrides:type_name -> openshell.v1.ProviderCredentialTokenGrantAudienceOverride + 83, // 55: openshell.v1.ProviderProfileCredential.refresh:type_name -> openshell.v1.ProviderCredentialRefresh + 79, // 56: openshell.v1.ProviderProfileCredential.token_grant:type_name -> openshell.v1.ProviderCredentialTokenGrant + 1, // 57: openshell.v1.ProviderCredentialRefresh.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 81, // 58: openshell.v1.ProviderCredentialRefresh.material:type_name -> openshell.v1.ProviderCredentialRefreshMaterial + 82, // 59: openshell.v1.ProviderCredentialRefresh.additional_outputs:type_name -> openshell.v1.ProviderCredentialRefreshOutput + 1, // 60: openshell.v1.ProviderCredentialRefreshStatus.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 217, // 61: openshell.v1.StoredProviderCredentialRefreshState.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 1, // 62: openshell.v1.StoredProviderCredentialRefreshState.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 203, // 63: openshell.v1.StoredProviderCredentialRefreshState.material:type_name -> openshell.v1.StoredProviderCredentialRefreshState.MaterialEntry + 204, // 64: openshell.v1.StoredProviderCredentialRefreshState.additional_output_keys:type_name -> openshell.v1.StoredProviderCredentialRefreshState.AdditionalOutputKeysEntry + 84, // 65: openshell.v1.GetProviderRefreshStatusResponse.credentials:type_name -> openshell.v1.ProviderCredentialRefreshStatus + 1, // 66: openshell.v1.ConfigureProviderRefreshRequest.strategy:type_name -> openshell.v1.ProviderCredentialRefreshStrategy + 205, // 67: openshell.v1.ConfigureProviderRefreshRequest.material:type_name -> openshell.v1.ConfigureProviderRefreshRequest.MaterialEntry + 84, // 68: openshell.v1.ConfigureProviderRefreshResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus + 84, // 69: openshell.v1.RotateProviderCredentialResponse.status:type_name -> openshell.v1.ProviderCredentialRefreshStatus + 2, // 70: openshell.v1.ProviderProfile.category:type_name -> openshell.v1.ProviderProfileCategory + 80, // 71: openshell.v1.ProviderProfile.credentials:type_name -> openshell.v1.ProviderProfileCredential + 221, // 72: openshell.v1.ProviderProfile.endpoints:type_name -> openshell.sandbox.v1.NetworkEndpoint + 222, // 73: openshell.v1.ProviderProfile.binaries:type_name -> openshell.sandbox.v1.NetworkBinary + 85, // 74: openshell.v1.ProviderProfile.discovery:type_name -> openshell.v1.ProviderProfileDiscovery + 206, // 75: openshell.v1.ProviderProfile.annotations:type_name -> openshell.v1.ProviderProfile.AnnotationsEntry + 217, // 76: openshell.v1.StoredProviderProfile.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 95, // 77: openshell.v1.StoredProviderProfile.profile:type_name -> openshell.v1.ProviderProfile + 95, // 78: openshell.v1.ProviderProfileResponse.profile:type_name -> openshell.v1.ProviderProfile + 95, // 79: openshell.v1.ListProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile + 76, // 80: openshell.v1.ImportProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem + 77, // 81: openshell.v1.ImportProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic + 95, // 82: openshell.v1.ImportProviderProfilesResponse.profiles:type_name -> openshell.v1.ProviderProfile + 76, // 83: openshell.v1.UpdateProviderProfilesRequest.profile:type_name -> openshell.v1.ProviderProfileImportItem + 77, // 84: openshell.v1.UpdateProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic + 95, // 85: openshell.v1.UpdateProviderProfilesResponse.profile:type_name -> openshell.v1.ProviderProfile + 76, // 86: openshell.v1.LintProviderProfilesRequest.profiles:type_name -> openshell.v1.ProviderProfileImportItem + 77, // 87: openshell.v1.LintProviderProfilesResponse.diagnostics:type_name -> openshell.v1.ProviderProfileDiagnostic + 109, // 88: openshell.v1.StaticCredentialBinding.endpoints:type_name -> openshell.v1.StaticCredentialEndpointBinding + 207, // 89: openshell.v1.GetSandboxProviderEnvironmentResponse.environment:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.EnvironmentEntry + 208, // 90: openshell.v1.GetSandboxProviderEnvironmentResponse.credential_expires_at_ms:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.CredentialExpiresAtMsEntry + 209, // 91: openshell.v1.GetSandboxProviderEnvironmentResponse.dynamic_credentials:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry + 210, // 92: openshell.v1.GetSandboxProviderEnvironmentResponse.static_credential_bindings:type_name -> openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry + 218, // 93: openshell.v1.UpdateConfigRequest.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 223, // 94: openshell.v1.UpdateConfigRequest.setting_value:type_name -> openshell.sandbox.v1.SettingValue + 113, // 95: openshell.v1.UpdateConfigRequest.merge_operations:type_name -> openshell.v1.PolicyMergeOperation + 211, // 96: openshell.v1.UpdateConfigRequest.annotations:type_name -> openshell.v1.UpdateConfigRequest.AnnotationsEntry + 114, // 97: openshell.v1.PolicyMergeOperation.add_rule:type_name -> openshell.v1.AddNetworkRule + 115, // 98: openshell.v1.PolicyMergeOperation.remove_endpoint:type_name -> openshell.v1.RemoveNetworkEndpoint + 116, // 99: openshell.v1.PolicyMergeOperation.remove_rule:type_name -> openshell.v1.RemoveNetworkRule + 117, // 100: openshell.v1.PolicyMergeOperation.add_deny_rules:type_name -> openshell.v1.AddDenyRules + 118, // 101: openshell.v1.PolicyMergeOperation.add_allow_rules:type_name -> openshell.v1.AddAllowRules + 119, // 102: openshell.v1.PolicyMergeOperation.remove_binary:type_name -> openshell.v1.RemoveNetworkBinary + 224, // 103: openshell.v1.AddNetworkRule.rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 225, // 104: openshell.v1.AddDenyRules.deny_rules:type_name -> openshell.sandbox.v1.L7DenyRule + 226, // 105: openshell.v1.AddAllowRules.rules:type_name -> openshell.sandbox.v1.L7Rule + 212, // 106: openshell.v1.UpdateConfigResponse.annotations:type_name -> openshell.v1.UpdateConfigResponse.AnnotationsEntry + 127, // 107: openshell.v1.GetSandboxPolicyStatusResponse.revision:type_name -> openshell.v1.SandboxPolicyRevision + 127, // 108: openshell.v1.ListSandboxPoliciesResponse.revisions:type_name -> openshell.v1.SandboxPolicyRevision + 3, // 109: openshell.v1.ReportPolicyStatusRequest.status:type_name -> openshell.v1.PolicyStatus + 3, // 110: openshell.v1.SandboxPolicyRevision.status:type_name -> openshell.v1.PolicyStatus + 218, // 111: openshell.v1.SandboxPolicyRevision.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 213, // 112: openshell.v1.SandboxPolicyRevision.provenance:type_name -> openshell.v1.SandboxPolicyRevision.ProvenanceEntry + 65, // 113: openshell.v1.PushSandboxLogsRequest.logs:type_name -> openshell.v1.SandboxLogLine + 65, // 114: openshell.v1.GetSandboxLogsResponse.logs:type_name -> openshell.v1.SandboxLogLine + 134, // 115: openshell.v1.SupervisorMessage.hello:type_name -> openshell.v1.SupervisorHello + 137, // 116: openshell.v1.SupervisorMessage.heartbeat:type_name -> openshell.v1.SupervisorHeartbeat + 146, // 117: openshell.v1.SupervisorMessage.relay_open_result:type_name -> openshell.v1.RelayOpenResult + 147, // 118: openshell.v1.SupervisorMessage.relay_close:type_name -> openshell.v1.RelayClose + 135, // 119: openshell.v1.GatewayMessage.session_accepted:type_name -> openshell.v1.SessionAccepted + 136, // 120: openshell.v1.GatewayMessage.session_rejected:type_name -> openshell.v1.SessionRejected + 138, // 121: openshell.v1.GatewayMessage.heartbeat:type_name -> openshell.v1.GatewayHeartbeat + 141, // 122: openshell.v1.GatewayMessage.relay_open:type_name -> openshell.v1.RelayOpen + 147, // 123: openshell.v1.GatewayMessage.relay_close:type_name -> openshell.v1.RelayClose + 142, // 124: openshell.v1.RelayOpen.ssh:type_name -> openshell.v1.SshRelayTarget + 143, // 125: openshell.v1.RelayOpen.tcp:type_name -> openshell.v1.TcpRelayTarget + 144, // 126: openshell.v1.RelayFrame.init:type_name -> openshell.v1.RelayInit + 148, // 127: openshell.v1.DenialSummary.l7_request_samples:type_name -> openshell.v1.L7RequestSample + 150, // 128: openshell.v1.NetworkActivitySummary.denials_by_group:type_name -> openshell.v1.DenialGroupCount + 224, // 129: openshell.v1.PolicyChunk.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 149, // 130: openshell.v1.SubmitPolicyAnalysisRequest.summaries:type_name -> openshell.v1.DenialSummary + 152, // 131: openshell.v1.SubmitPolicyAnalysisRequest.proposed_chunks:type_name -> openshell.v1.PolicyChunk + 151, // 132: openshell.v1.SubmitPolicyAnalysisRequest.network_activity_summaries:type_name -> openshell.v1.NetworkActivitySummary + 152, // 133: openshell.v1.GetDraftPolicyResponse.chunks:type_name -> openshell.v1.PolicyChunk + 224, // 134: openshell.v1.EditDraftChunkRequest.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 171, // 135: openshell.v1.GetDraftHistoryResponse.entries:type_name -> openshell.v1.DraftHistoryEntry + 218, // 136: openshell.v1.PolicyRevisionPayload.policy:type_name -> openshell.sandbox.v1.SandboxPolicy + 214, // 137: openshell.v1.PolicyRevisionPayload.provenance:type_name -> openshell.v1.PolicyRevisionPayload.ProvenanceEntry + 224, // 138: openshell.v1.DraftChunkPayload.proposed_rule:type_name -> openshell.sandbox.v1.NetworkPolicyRule + 215, // 139: openshell.v1.StoredPolicyRevision.provenance:type_name -> openshell.v1.StoredPolicyRevision.ProvenanceEntry + 216, // 140: openshell.v1.CreateWorkspaceRequest.labels:type_name -> openshell.v1.CreateWorkspaceRequest.LabelsEntry + 227, // 141: openshell.v1.CreateWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace + 227, // 142: openshell.v1.GetWorkspaceResponse.workspace:type_name -> openshell.datamodel.v1.Workspace + 227, // 143: openshell.v1.ListWorkspacesResponse.workspaces:type_name -> openshell.datamodel.v1.Workspace + 217, // 144: openshell.v1.WorkspaceMember.metadata:type_name -> openshell.datamodel.v1.ObjectMeta + 5, // 145: openshell.v1.WorkspaceMember.role:type_name -> openshell.v1.WorkspaceRole + 5, // 146: openshell.v1.AddWorkspaceMemberRequest.role:type_name -> openshell.v1.WorkspaceRole + 185, // 147: openshell.v1.AddWorkspaceMemberResponse.member:type_name -> openshell.v1.WorkspaceMember + 185, // 148: openshell.v1.ListWorkspaceMembersResponse.members:type_name -> openshell.v1.WorkspaceMember + 80, // 149: openshell.v1.GetSandboxProviderEnvironmentResponse.DynamicCredentialsEntry.value:type_name -> openshell.v1.ProviderProfileCredential + 110, // 150: openshell.v1.GetSandboxProviderEnvironmentResponse.StaticCredentialBindingsEntry.value:type_name -> openshell.v1.StaticCredentialBinding + 10, // 151: openshell.v1.OpenShell.Health:input_type -> openshell.v1.HealthRequest + 12, // 152: openshell.v1.OpenShell.GetCurrentUser:input_type -> openshell.v1.GetCurrentUserRequest + 14, // 153: openshell.v1.OpenShell.GetGatewayInfo:input_type -> openshell.v1.GetGatewayInfoRequest + 26, // 154: openshell.v1.OpenShell.CreateSandbox:input_type -> openshell.v1.CreateSandboxRequest + 27, // 155: openshell.v1.OpenShell.GetSandbox:input_type -> openshell.v1.GetSandboxRequest + 28, // 156: openshell.v1.OpenShell.ListSandboxes:input_type -> openshell.v1.ListSandboxesRequest + 29, // 157: openshell.v1.OpenShell.ListSandboxProviders:input_type -> openshell.v1.ListSandboxProvidersRequest + 30, // 158: openshell.v1.OpenShell.AttachSandboxProvider:input_type -> openshell.v1.AttachSandboxProviderRequest + 31, // 159: openshell.v1.OpenShell.DetachSandboxProvider:input_type -> openshell.v1.DetachSandboxProviderRequest + 32, // 160: openshell.v1.OpenShell.DeleteSandbox:input_type -> openshell.v1.DeleteSandboxRequest + 33, // 161: openshell.v1.OpenShell.StopSandbox:input_type -> openshell.v1.StopSandboxRequest + 34, // 162: openshell.v1.OpenShell.StartSandbox:input_type -> openshell.v1.StartSandboxRequest + 41, // 163: openshell.v1.OpenShell.CreateSshSession:input_type -> openshell.v1.CreateSshSessionRequest + 43, // 164: openshell.v1.OpenShell.ExposeService:input_type -> openshell.v1.ExposeServiceRequest + 44, // 165: openshell.v1.OpenShell.GetService:input_type -> openshell.v1.GetServiceRequest + 45, // 166: openshell.v1.OpenShell.ListServices:input_type -> openshell.v1.ListServicesRequest + 47, // 167: openshell.v1.OpenShell.DeleteService:input_type -> openshell.v1.DeleteServiceRequest + 51, // 168: openshell.v1.OpenShell.RevokeSshSession:input_type -> openshell.v1.RevokeSshSessionRequest + 53, // 169: openshell.v1.OpenShell.ExecSandbox:input_type -> openshell.v1.ExecSandboxRequest + 59, // 170: openshell.v1.OpenShell.ForwardTcp:input_type -> openshell.v1.TcpForwardFrame + 60, // 171: openshell.v1.OpenShell.ExecSandboxInteractive:input_type -> openshell.v1.ExecSandboxInput + 67, // 172: openshell.v1.OpenShell.CreateProvider:input_type -> openshell.v1.CreateProviderRequest + 68, // 173: openshell.v1.OpenShell.GetProvider:input_type -> openshell.v1.GetProviderRequest + 69, // 174: openshell.v1.OpenShell.ListProviders:input_type -> openshell.v1.ListProvidersRequest + 74, // 175: openshell.v1.OpenShell.ListProviderProfiles:input_type -> openshell.v1.ListProviderProfilesRequest + 75, // 176: openshell.v1.OpenShell.GetProviderProfile:input_type -> openshell.v1.GetProviderProfileRequest + 99, // 177: openshell.v1.OpenShell.ImportProviderProfiles:input_type -> openshell.v1.ImportProviderProfilesRequest + 101, // 178: openshell.v1.OpenShell.UpdateProviderProfiles:input_type -> openshell.v1.UpdateProviderProfilesRequest + 103, // 179: openshell.v1.OpenShell.LintProviderProfiles:input_type -> openshell.v1.LintProviderProfilesRequest + 70, // 180: openshell.v1.OpenShell.UpdateProvider:input_type -> openshell.v1.UpdateProviderRequest + 87, // 181: openshell.v1.OpenShell.GetProviderRefreshStatus:input_type -> openshell.v1.GetProviderRefreshStatusRequest + 89, // 182: openshell.v1.OpenShell.ConfigureProviderRefresh:input_type -> openshell.v1.ConfigureProviderRefreshRequest + 91, // 183: openshell.v1.OpenShell.RotateProviderCredential:input_type -> openshell.v1.RotateProviderCredentialRequest + 93, // 184: openshell.v1.OpenShell.DeleteProviderRefresh:input_type -> openshell.v1.DeleteProviderRefreshRequest + 71, // 185: openshell.v1.OpenShell.DeleteProvider:input_type -> openshell.v1.DeleteProviderRequest + 106, // 186: openshell.v1.OpenShell.DeleteProviderProfile:input_type -> openshell.v1.DeleteProviderProfileRequest + 228, // 187: openshell.v1.OpenShell.GetSandboxConfig:input_type -> openshell.sandbox.v1.GetSandboxConfigRequest + 229, // 188: openshell.v1.OpenShell.GetGatewayConfig:input_type -> openshell.sandbox.v1.GetGatewayConfigRequest + 112, // 189: openshell.v1.OpenShell.UpdateConfig:input_type -> openshell.v1.UpdateConfigRequest + 121, // 190: openshell.v1.OpenShell.GetSandboxPolicyStatus:input_type -> openshell.v1.GetSandboxPolicyStatusRequest + 123, // 191: openshell.v1.OpenShell.ListSandboxPolicies:input_type -> openshell.v1.ListSandboxPoliciesRequest + 125, // 192: openshell.v1.OpenShell.ReportPolicyStatus:input_type -> openshell.v1.ReportPolicyStatusRequest + 108, // 193: openshell.v1.OpenShell.GetSandboxProviderEnvironment:input_type -> openshell.v1.GetSandboxProviderEnvironmentRequest + 128, // 194: openshell.v1.OpenShell.GetSandboxLogs:input_type -> openshell.v1.GetSandboxLogsRequest + 129, // 195: openshell.v1.OpenShell.PushSandboxLogs:input_type -> openshell.v1.PushSandboxLogsRequest + 132, // 196: openshell.v1.OpenShell.ConnectSupervisor:input_type -> openshell.v1.SupervisorMessage + 139, // 197: openshell.v1.OpenShell.ReportMainProcessExit:input_type -> openshell.v1.ReportMainProcessExitRequest + 145, // 198: openshell.v1.OpenShell.RelayStream:input_type -> openshell.v1.RelayFrame + 63, // 199: openshell.v1.OpenShell.WatchSandbox:input_type -> openshell.v1.WatchSandboxRequest + 154, // 200: openshell.v1.OpenShell.SubmitPolicyAnalysis:input_type -> openshell.v1.SubmitPolicyAnalysisRequest + 156, // 201: openshell.v1.OpenShell.GetDraftPolicy:input_type -> openshell.v1.GetDraftPolicyRequest + 158, // 202: openshell.v1.OpenShell.ApproveDraftChunk:input_type -> openshell.v1.ApproveDraftChunkRequest + 160, // 203: openshell.v1.OpenShell.RejectDraftChunk:input_type -> openshell.v1.RejectDraftChunkRequest + 162, // 204: openshell.v1.OpenShell.ApproveAllDraftChunks:input_type -> openshell.v1.ApproveAllDraftChunksRequest + 164, // 205: openshell.v1.OpenShell.EditDraftChunk:input_type -> openshell.v1.EditDraftChunkRequest + 166, // 206: openshell.v1.OpenShell.UndoDraftChunk:input_type -> openshell.v1.UndoDraftChunkRequest + 168, // 207: openshell.v1.OpenShell.ClearDraftChunks:input_type -> openshell.v1.ClearDraftChunksRequest + 170, // 208: openshell.v1.OpenShell.GetDraftHistory:input_type -> openshell.v1.GetDraftHistoryRequest + 6, // 209: openshell.v1.OpenShell.IssueSandboxToken:input_type -> openshell.v1.IssueSandboxTokenRequest + 8, // 210: openshell.v1.OpenShell.RefreshSandboxToken:input_type -> openshell.v1.RefreshSandboxTokenRequest + 177, // 211: openshell.v1.OpenShell.CreateWorkspace:input_type -> openshell.v1.CreateWorkspaceRequest + 179, // 212: openshell.v1.OpenShell.GetWorkspace:input_type -> openshell.v1.GetWorkspaceRequest + 181, // 213: openshell.v1.OpenShell.ListWorkspaces:input_type -> openshell.v1.ListWorkspacesRequest + 183, // 214: openshell.v1.OpenShell.DeleteWorkspace:input_type -> openshell.v1.DeleteWorkspaceRequest + 186, // 215: openshell.v1.OpenShell.AddWorkspaceMember:input_type -> openshell.v1.AddWorkspaceMemberRequest + 188, // 216: openshell.v1.OpenShell.RemoveWorkspaceMember:input_type -> openshell.v1.RemoveWorkspaceMemberRequest + 190, // 217: openshell.v1.OpenShell.ListWorkspaceMembers:input_type -> openshell.v1.ListWorkspaceMembersRequest + 11, // 218: openshell.v1.OpenShell.Health:output_type -> openshell.v1.HealthResponse + 13, // 219: openshell.v1.OpenShell.GetCurrentUser:output_type -> openshell.v1.GetCurrentUserResponse + 15, // 220: openshell.v1.OpenShell.GetGatewayInfo:output_type -> openshell.v1.GetGatewayInfoResponse + 35, // 221: openshell.v1.OpenShell.CreateSandbox:output_type -> openshell.v1.SandboxResponse + 35, // 222: openshell.v1.OpenShell.GetSandbox:output_type -> openshell.v1.SandboxResponse + 36, // 223: openshell.v1.OpenShell.ListSandboxes:output_type -> openshell.v1.ListSandboxesResponse + 37, // 224: openshell.v1.OpenShell.ListSandboxProviders:output_type -> openshell.v1.ListSandboxProvidersResponse + 38, // 225: openshell.v1.OpenShell.AttachSandboxProvider:output_type -> openshell.v1.AttachSandboxProviderResponse + 39, // 226: openshell.v1.OpenShell.DetachSandboxProvider:output_type -> openshell.v1.DetachSandboxProviderResponse + 40, // 227: openshell.v1.OpenShell.DeleteSandbox:output_type -> openshell.v1.DeleteSandboxResponse + 35, // 228: openshell.v1.OpenShell.StopSandbox:output_type -> openshell.v1.SandboxResponse + 35, // 229: openshell.v1.OpenShell.StartSandbox:output_type -> openshell.v1.SandboxResponse + 42, // 230: openshell.v1.OpenShell.CreateSshSession:output_type -> openshell.v1.CreateSshSessionResponse + 50, // 231: openshell.v1.OpenShell.ExposeService:output_type -> openshell.v1.ServiceEndpointResponse + 50, // 232: openshell.v1.OpenShell.GetService:output_type -> openshell.v1.ServiceEndpointResponse + 46, // 233: openshell.v1.OpenShell.ListServices:output_type -> openshell.v1.ListServicesResponse + 48, // 234: openshell.v1.OpenShell.DeleteService:output_type -> openshell.v1.DeleteServiceResponse + 52, // 235: openshell.v1.OpenShell.RevokeSshSession:output_type -> openshell.v1.RevokeSshSessionResponse + 57, // 236: openshell.v1.OpenShell.ExecSandbox:output_type -> openshell.v1.ExecSandboxEvent + 59, // 237: openshell.v1.OpenShell.ForwardTcp:output_type -> openshell.v1.TcpForwardFrame + 57, // 238: openshell.v1.OpenShell.ExecSandboxInteractive:output_type -> openshell.v1.ExecSandboxEvent + 72, // 239: openshell.v1.OpenShell.CreateProvider:output_type -> openshell.v1.ProviderResponse + 72, // 240: openshell.v1.OpenShell.GetProvider:output_type -> openshell.v1.ProviderResponse + 73, // 241: openshell.v1.OpenShell.ListProviders:output_type -> openshell.v1.ListProvidersResponse + 98, // 242: openshell.v1.OpenShell.ListProviderProfiles:output_type -> openshell.v1.ListProviderProfilesResponse + 97, // 243: openshell.v1.OpenShell.GetProviderProfile:output_type -> openshell.v1.ProviderProfileResponse + 100, // 244: openshell.v1.OpenShell.ImportProviderProfiles:output_type -> openshell.v1.ImportProviderProfilesResponse + 102, // 245: openshell.v1.OpenShell.UpdateProviderProfiles:output_type -> openshell.v1.UpdateProviderProfilesResponse + 104, // 246: openshell.v1.OpenShell.LintProviderProfiles:output_type -> openshell.v1.LintProviderProfilesResponse + 72, // 247: openshell.v1.OpenShell.UpdateProvider:output_type -> openshell.v1.ProviderResponse + 88, // 248: openshell.v1.OpenShell.GetProviderRefreshStatus:output_type -> openshell.v1.GetProviderRefreshStatusResponse + 90, // 249: openshell.v1.OpenShell.ConfigureProviderRefresh:output_type -> openshell.v1.ConfigureProviderRefreshResponse + 92, // 250: openshell.v1.OpenShell.RotateProviderCredential:output_type -> openshell.v1.RotateProviderCredentialResponse + 94, // 251: openshell.v1.OpenShell.DeleteProviderRefresh:output_type -> openshell.v1.DeleteProviderRefreshResponse + 105, // 252: openshell.v1.OpenShell.DeleteProvider:output_type -> openshell.v1.DeleteProviderResponse + 107, // 253: openshell.v1.OpenShell.DeleteProviderProfile:output_type -> openshell.v1.DeleteProviderProfileResponse + 230, // 254: openshell.v1.OpenShell.GetSandboxConfig:output_type -> openshell.sandbox.v1.GetSandboxConfigResponse + 231, // 255: openshell.v1.OpenShell.GetGatewayConfig:output_type -> openshell.sandbox.v1.GetGatewayConfigResponse + 120, // 256: openshell.v1.OpenShell.UpdateConfig:output_type -> openshell.v1.UpdateConfigResponse + 122, // 257: openshell.v1.OpenShell.GetSandboxPolicyStatus:output_type -> openshell.v1.GetSandboxPolicyStatusResponse + 124, // 258: openshell.v1.OpenShell.ListSandboxPolicies:output_type -> openshell.v1.ListSandboxPoliciesResponse + 126, // 259: openshell.v1.OpenShell.ReportPolicyStatus:output_type -> openshell.v1.ReportPolicyStatusResponse + 111, // 260: openshell.v1.OpenShell.GetSandboxProviderEnvironment:output_type -> openshell.v1.GetSandboxProviderEnvironmentResponse + 131, // 261: openshell.v1.OpenShell.GetSandboxLogs:output_type -> openshell.v1.GetSandboxLogsResponse + 130, // 262: openshell.v1.OpenShell.PushSandboxLogs:output_type -> openshell.v1.PushSandboxLogsResponse + 133, // 263: openshell.v1.OpenShell.ConnectSupervisor:output_type -> openshell.v1.GatewayMessage + 140, // 264: openshell.v1.OpenShell.ReportMainProcessExit:output_type -> openshell.v1.ReportMainProcessExitResponse + 145, // 265: openshell.v1.OpenShell.RelayStream:output_type -> openshell.v1.RelayFrame + 64, // 266: openshell.v1.OpenShell.WatchSandbox:output_type -> openshell.v1.SandboxStreamEvent + 155, // 267: openshell.v1.OpenShell.SubmitPolicyAnalysis:output_type -> openshell.v1.SubmitPolicyAnalysisResponse + 157, // 268: openshell.v1.OpenShell.GetDraftPolicy:output_type -> openshell.v1.GetDraftPolicyResponse + 159, // 269: openshell.v1.OpenShell.ApproveDraftChunk:output_type -> openshell.v1.ApproveDraftChunkResponse + 161, // 270: openshell.v1.OpenShell.RejectDraftChunk:output_type -> openshell.v1.RejectDraftChunkResponse + 163, // 271: openshell.v1.OpenShell.ApproveAllDraftChunks:output_type -> openshell.v1.ApproveAllDraftChunksResponse + 165, // 272: openshell.v1.OpenShell.EditDraftChunk:output_type -> openshell.v1.EditDraftChunkResponse + 167, // 273: openshell.v1.OpenShell.UndoDraftChunk:output_type -> openshell.v1.UndoDraftChunkResponse + 169, // 274: openshell.v1.OpenShell.ClearDraftChunks:output_type -> openshell.v1.ClearDraftChunksResponse + 172, // 275: openshell.v1.OpenShell.GetDraftHistory:output_type -> openshell.v1.GetDraftHistoryResponse + 7, // 276: openshell.v1.OpenShell.IssueSandboxToken:output_type -> openshell.v1.IssueSandboxTokenResponse + 9, // 277: openshell.v1.OpenShell.RefreshSandboxToken:output_type -> openshell.v1.RefreshSandboxTokenResponse + 178, // 278: openshell.v1.OpenShell.CreateWorkspace:output_type -> openshell.v1.CreateWorkspaceResponse + 180, // 279: openshell.v1.OpenShell.GetWorkspace:output_type -> openshell.v1.GetWorkspaceResponse + 182, // 280: openshell.v1.OpenShell.ListWorkspaces:output_type -> openshell.v1.ListWorkspacesResponse + 184, // 281: openshell.v1.OpenShell.DeleteWorkspace:output_type -> openshell.v1.DeleteWorkspaceResponse + 187, // 282: openshell.v1.OpenShell.AddWorkspaceMember:output_type -> openshell.v1.AddWorkspaceMemberResponse + 189, // 283: openshell.v1.OpenShell.RemoveWorkspaceMember:output_type -> openshell.v1.RemoveWorkspaceMemberResponse + 191, // 284: openshell.v1.OpenShell.ListWorkspaceMembers:output_type -> openshell.v1.ListWorkspaceMembersResponse + 218, // [218:285] is the sub-list for method output_type + 151, // [151:218] is the sub-list for method input_type + 151, // [151:151] is the sub-list for extension type_name + 151, // [151:151] is the sub-list for extension extendee + 0, // [0:151] is the sub-list for field type_name } func init() { file_openshell_proto_init() } @@ -15275,36 +14973,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[19].OneofWrappers = []any{} - file_openshell_proto_msgTypes[53].OneofWrappers = []any{ + file_openshell_proto_msgTypes[51].OneofWrappers = []any{ (*ExecSandboxEvent_Stdout)(nil), (*ExecSandboxEvent_Stderr)(nil), (*ExecSandboxEvent_Exit)(nil), } - file_openshell_proto_msgTypes[54].OneofWrappers = []any{ + file_openshell_proto_msgTypes[52].OneofWrappers = []any{ (*TcpForwardInit_Ssh)(nil), (*TcpForwardInit_Tcp)(nil), } - file_openshell_proto_msgTypes[55].OneofWrappers = []any{ + file_openshell_proto_msgTypes[53].OneofWrappers = []any{ (*TcpForwardFrame_Init)(nil), (*TcpForwardFrame_Data)(nil), } - file_openshell_proto_msgTypes[56].OneofWrappers = []any{ + file_openshell_proto_msgTypes[54].OneofWrappers = []any{ (*ExecSandboxInput_Start)(nil), (*ExecSandboxInput_Stdin)(nil), (*ExecSandboxInput_Resize)(nil), } - file_openshell_proto_msgTypes[60].OneofWrappers = []any{ + file_openshell_proto_msgTypes[58].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[109].OneofWrappers = []any{ + file_openshell_proto_msgTypes[83].OneofWrappers = []any{} + file_openshell_proto_msgTypes[107].OneofWrappers = []any{ (*PolicyMergeOperation_AddRule)(nil), (*PolicyMergeOperation_RemoveEndpoint)(nil), (*PolicyMergeOperation_RemoveRule)(nil), @@ -15312,39 +15010,36 @@ func file_openshell_proto_init() { (*PolicyMergeOperation_AddAllowRules)(nil), (*PolicyMergeOperation_RemoveBinary)(nil), } - file_openshell_proto_msgTypes[128].OneofWrappers = []any{ + file_openshell_proto_msgTypes[126].OneofWrappers = []any{ (*SupervisorMessage_Hello)(nil), (*SupervisorMessage_Heartbeat)(nil), (*SupervisorMessage_RelayOpenResult)(nil), (*SupervisorMessage_RelayClose)(nil), - (*SupervisorMessage_MainProcessExit)(nil), } - file_openshell_proto_msgTypes[129].OneofWrappers = []any{ + file_openshell_proto_msgTypes[127].OneofWrappers = []any{ (*GatewayMessage_SessionAccepted)(nil), (*GatewayMessage_SessionRejected)(nil), (*GatewayMessage_Heartbeat)(nil), (*GatewayMessage_RelayOpen)(nil), (*GatewayMessage_RelayClose)(nil), - (*GatewayMessage_MainProcessExitAck)(nil), } - file_openshell_proto_msgTypes[135].OneofWrappers = []any{} - file_openshell_proto_msgTypes[137].OneofWrappers = []any{ + file_openshell_proto_msgTypes[135].OneofWrappers = []any{ (*RelayOpen_Ssh)(nil), (*RelayOpen_Tcp)(nil), } - file_openshell_proto_msgTypes[141].OneofWrappers = []any{ + file_openshell_proto_msgTypes[139].OneofWrappers = []any{ (*RelayFrame_Init)(nil), (*RelayFrame_Data)(nil), } - file_openshell_proto_msgTypes[171].OneofWrappers = []any{} - file_openshell_proto_msgTypes[172].OneofWrappers = []any{} + file_openshell_proto_msgTypes[169].OneofWrappers = []any{} + file_openshell_proto_msgTypes[170].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: 7, - NumMessages: 214, + NumEnums: 6, + NumMessages: 211, 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 92c94ef299..2ea9410c3e 100644 --- a/sdk/go/proto/openshellv1/openshell_grpc.pb.go +++ b/sdk/go/proto/openshellv1/openshell_grpc.pb.go @@ -69,6 +69,7 @@ const ( 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_RelayStream_FullMethodName = "/openshell.v1.OpenShell/RelayStream" OpenShell_WatchSandbox_FullMethodName = "/openshell.v1.OpenShell/WatchSandbox" OpenShell_SubmitPolicyAnalysis_FullMethodName = "/openshell.v1.OpenShell/SubmitPolicyAnalysis" @@ -211,6 +212,8 @@ type OpenShellClient interface { // bytes flow over RelayStream calls (separate HTTP/2 streams on the same // connection), not over this stream. ConnectSupervisor(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[SupervisorMessage, GatewayMessage], error) + // Persist the canonical main process result before the supervisor exits. + ReportMainProcessExit(ctx context.Context, in *ReportMainProcessExitRequest, opts ...grpc.CallOption) (*ReportMainProcessExitResponse, error) // Raw byte relay between supervisor and gateway. // // The supervisor initiates this call after receiving a RelayOpen message @@ -766,6 +769,16 @@ func (c *openShellClient) ConnectSupervisor(ctx context.Context, opts ...grpc.Ca // This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. type OpenShell_ConnectSupervisorClient = grpc.BidiStreamingClient[SupervisorMessage, GatewayMessage] +func (c *openShellClient) ReportMainProcessExit(ctx context.Context, in *ReportMainProcessExitRequest, opts ...grpc.CallOption) (*ReportMainProcessExitResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ReportMainProcessExitResponse) + err := c.cc.Invoke(ctx, OpenShell_ReportMainProcessExit_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *openShellClient) RelayStream(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[RelayFrame, RelayFrame], error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) stream, err := c.cc.NewStream(ctx, &OpenShell_ServiceDesc.Streams[5], OpenShell_RelayStream_FullMethodName, cOpts...) @@ -1098,6 +1111,8 @@ type OpenShellServer interface { // bytes flow over RelayStream calls (separate HTTP/2 streams on the same // connection), not over this stream. ConnectSupervisor(grpc.BidiStreamingServer[SupervisorMessage, GatewayMessage]) error + // Persist the canonical main process result before the supervisor exits. + ReportMainProcessExit(context.Context, *ReportMainProcessExitRequest) (*ReportMainProcessExitResponse, error) // Raw byte relay between supervisor and gateway. // // The supervisor initiates this call after receiving a RelayOpen message @@ -1310,6 +1325,9 @@ func (UnimplementedOpenShellServer) PushSandboxLogs(grpc.ClientStreamingServer[P func (UnimplementedOpenShellServer) ConnectSupervisor(grpc.BidiStreamingServer[SupervisorMessage, GatewayMessage]) error { return status.Error(codes.Unimplemented, "method ConnectSupervisor not implemented") } +func (UnimplementedOpenShellServer) ReportMainProcessExit(context.Context, *ReportMainProcessExitRequest) (*ReportMainProcessExitResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ReportMainProcessExit not implemented") +} func (UnimplementedOpenShellServer) RelayStream(grpc.BidiStreamingServer[RelayFrame, RelayFrame]) error { return status.Error(codes.Unimplemented, "method RelayStream not implemented") } @@ -2168,6 +2186,24 @@ func _OpenShell_ConnectSupervisor_Handler(srv interface{}, stream grpc.ServerStr // This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. type OpenShell_ConnectSupervisorServer = grpc.BidiStreamingServer[SupervisorMessage, GatewayMessage] +func _OpenShell_ReportMainProcessExit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ReportMainProcessExitRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(OpenShellServer).ReportMainProcessExit(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: OpenShell_ReportMainProcessExit_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(OpenShellServer).ReportMainProcessExit(ctx, req.(*ReportMainProcessExitRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _OpenShell_RelayStream_Handler(srv interface{}, stream grpc.ServerStream) error { return srv.(OpenShellServer).RelayStream(&grpc.GenericServerStream[RelayFrame, RelayFrame]{ServerStream: stream}) } @@ -2681,6 +2717,10 @@ var OpenShell_ServiceDesc = grpc.ServiceDesc{ MethodName: "GetSandboxLogs", Handler: _OpenShell_GetSandboxLogs_Handler, }, + { + MethodName: "ReportMainProcessExit", + Handler: _OpenShell_ReportMainProcessExit_Handler, + }, { MethodName: "SubmitPolicyAnalysis", Handler: _OpenShell_SubmitPolicyAnalysis_Handler, From 13a68a6541f4e3464809ca11d3844e5509435f5e Mon Sep 17 00:00:00 2001 From: Drew Newberry Date: Tue, 18 Aug 2026 17:17:52 -0700 Subject: [PATCH 3/8] fix(sandbox): preserve legacy VM main compatibility Signed-off-by: Drew Newberry --- .agents/skills/openshell-cli/cli-reference.md | 21 +++- crates/openshell-core/src/sandbox_env.rs | 23 +++- crates/openshell-driver-vm/src/driver.rs | 34 +++++ e2e/rust/src/harness/sandbox.rs | 40 ++++++ e2e/rust/tests/sandbox_lifecycle.rs | 119 ++++++++++++++++++ 5 files changed, 229 insertions(+), 8 deletions(-) diff --git a/.agents/skills/openshell-cli/cli-reference.md b/.agents/skills/openshell-cli/cli-reference.md index 2cd5881ab9..d9d143b7a7 100644 --- a/.agents/skills/openshell-cli/cli-reference.md +++ b/.agents/skills/openshell-cli/cli-reference.md @@ -204,13 +204,17 @@ identity provider. Requires an authenticated gateway connection. ### `openshell sandbox create [OPTIONS] [-- COMMAND...]` -Create a sandbox through the selected gateway, wait for readiness, then connect, open an editor, or execute the trailing command. +Create a sandbox through the selected gateway and launch its canonical main +process. By default, the CLI attaches to that retained process after the +sandbox becomes ready. A trailing command defines the canonical main process; +without one, the default is `/bin/bash -l` with a PTY. | Flag | Description | |------|-------------| | `--name ` | Sandbox name (auto-generated if omitted) | | `--from ` | Community name, Dockerfile path, directory, or image reference (BYOC) | | `--no-keep` | Delete the sandbox after the initial command or shell exits | +| `--detach` | Start the canonical main process without attaching | | `--editor vscode|cursor` | Launch a remote editor and keep the sandbox alive | | `--gpu [COUNT]` | Request the driver's default GPU selection or a specific count | | `--cpu ` | CPU limit (for example: `500m`, `1`, `2.5`) | @@ -227,7 +231,12 @@ Create a sandbox through the selected gateway, wait for readiness, then connect, | `--approval-mode manual|auto` | Handle agent-authored policy proposals; default: `manual` | | `--upload [:]` | Upload local files to the working directory or an explicit destination (repeatable) | | `--no-git-ignore` | Disable `.gitignore` filtering for `--upload` | -| `[-- COMMAND...]` | Initial command (defaults to an interactive shell) | +| `[-- COMMAND...]` | Canonical main command (defaults to `/bin/bash -l`) | + +`--upload` cannot be combined with a trailing main command because uploads +currently complete after the canonical process starts. Create the default +scratch sandbox, upload files, then use `sandbox exec`, or build the files into +the image. ### `openshell sandbox get [name]` @@ -277,7 +286,13 @@ Execute a command through the gRPC exec endpoint, stream its output, and exit wi ### `openshell sandbox connect [name]` -Open an interactive SSH shell. The name defaults to the last-used sandbox. `--editor vscode|cursor` launches a supported remote editor instead. +Attach to the sandbox's retained canonical main process. Disconnecting leaves +the process running. Reconnecting targets the same process instance and +replays recent output. Use `sandbox exec --tty -- /bin/bash -l` when you need a +new shell. The name defaults to the last-used sandbox. + +`--editor vscode|cursor` launches a supported remote editor instead of +attaching to the canonical main process. ### `openshell sandbox upload [dest]` diff --git a/crates/openshell-core/src/sandbox_env.rs b/crates/openshell-core/src/sandbox_env.rs index 76faba74b3..4e672d4498 100644 --- a/crates/openshell-core/src/sandbox_env.rs +++ b/crates/openshell-core/src/sandbox_env.rs @@ -53,11 +53,14 @@ impl MainProcessConfig { #[must_use] pub fn from_driver_spec(spec: Option<&crate::proto::compute::v1::DriverSandboxSpec>) -> Self { - spec.map_or_else(Self::scratch, |spec| Self { - version: Self::VERSION, - command: spec.command.clone(), - tty: spec.tty, - }) + match spec { + Some(spec) if !spec.command.is_empty() => Self { + version: Self::VERSION, + command: spec.command.clone(), + tty: spec.tty, + }, + None | Some(_) => Self::scratch(), + } } /// Decode the versioned transport without shell interpretation. @@ -213,4 +216,14 @@ mod tests { .unwrap_err(); assert!(error.contains("unsupported")); } + + #[test] + fn legacy_driver_spec_without_command_uses_scratch_main() { + let legacy = crate::proto::compute::v1::DriverSandboxSpec::default(); + let config = MainProcessConfig::from_driver_spec(Some(&legacy)); + + assert_eq!(config, MainProcessConfig::scratch()); + let encoded = serde_json::to_string(&config).unwrap(); + assert_eq!(MainProcessConfig::decode(&encoded).unwrap(), config); + } } diff --git a/crates/openshell-driver-vm/src/driver.rs b/crates/openshell-driver-vm/src/driver.rs index 950d18cc49..137ee06f49 100644 --- a/crates/openshell-driver-vm/src/driver.rs +++ b/crates/openshell-driver-vm/src/driver.rs @@ -7045,6 +7045,40 @@ mod tests { ))); } + #[test] + fn persisted_legacy_sandbox_without_command_uses_scratch_main() { + let config = VmDriverConfig { + openshell_endpoint: "http://127.0.0.1:8080".to_string(), + ..Default::default() + }; + // Requests persisted before the canonical-main contract have a + // present DriverSandboxSpec but no command or tty fields. + let sandbox = Sandbox { + id: "legacy-sandbox".to_string(), + name: "legacy-sandbox".to_string(), + spec: Some(SandboxSpec::default()), + ..Default::default() + }; + + let env = build_guest_environment(&sandbox, &config, None); + let encoded = env + .iter() + .find_map(|entry| { + entry.strip_prefix(&format!( + "{}=", + openshell_core::sandbox_env::MAIN_PROCESS_SPEC + )) + }) + .expect("main process environment"); + let main = openshell_core::sandbox_env::MainProcessConfig::decode(encoded) + .expect("legacy persisted request should produce a valid main config"); + + assert_eq!( + main, + openshell_core::sandbox_env::MainProcessConfig::scratch() + ); + } + #[test] fn build_guest_environment_uses_token_file_without_raw_token_env() { let config = VmDriverConfig { diff --git a/e2e/rust/src/harness/sandbox.rs b/e2e/rust/src/harness/sandbox.rs index 1ee676d839..16839ee6b7 100644 --- a/e2e/rust/src/harness/sandbox.rs +++ b/e2e/rust/src/harness/sandbox.rs @@ -147,6 +147,46 @@ impl SandboxGuard { Self::create_keep_with_args(&[], command, ready_marker).await } + /// Create a sandbox with a detached canonical main command. + /// + /// Unlike [`SandboxGuard::create_keep`], this does not open an attachment, + /// which lets tests control competing and reconnecting clients directly. + pub async fn create_detached_main(command: &[&str]) -> Result { + let mut cmd = openshell_cmd(); + cmd.arg("sandbox") + .arg("create") + .arg("--detach") + .arg("--") + .args(command) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + + let output = timeout(SANDBOX_READY_TIMEOUT, cmd.output()) + .await + .map_err(|_| format!("sandbox create timed out after {SANDBOX_READY_TIMEOUT:?}"))? + .map_err(|e| format!("failed to spawn openshell: {e}"))?; + let stdout = String::from_utf8_lossy(&output.stdout).to_string(); + let stderr = String::from_utf8_lossy(&output.stderr).to_string(); + let combined = format!("{stdout}{stderr}"); + + if !output.status.success() { + return Err(format!( + "sandbox create failed (exit {:?}):\n{combined}", + output.status.code() + )); + } + + let name = extract_sandbox_name(&combined).ok_or_else(|| { + format!("could not parse sandbox name from create output:\n{combined}") + })?; + Ok(Self { + name, + create_output: combined, + child: None, + cleaned_up: false, + }) + } + /// Like [`SandboxGuard::create_keep`], but forwards extra flags to /// `sandbox create` (e.g. `--policy `, `--name `) before the /// `-- ` separator. diff --git a/e2e/rust/tests/sandbox_lifecycle.rs b/e2e/rust/tests/sandbox_lifecycle.rs index 74f15f6313..ce442301ce 100644 --- a/e2e/rust/tests/sandbox_lifecycle.rs +++ b/e2e/rust/tests/sandbox_lifecycle.rs @@ -9,6 +9,7 @@ use std::time::Duration; use openshell_e2e::harness::binary::{openshell_cmd, openshell_tty_cmd}; use openshell_e2e::harness::output::{extract_field, strip_ansi}; use openshell_e2e::harness::sandbox::SandboxGuard; +use tokio::io::{AsyncBufReadExt, BufReader}; use tokio::time::{Instant, sleep}; const SANDBOX_PRESENCE_TIMEOUT: Duration = Duration::from_secs(30); @@ -266,6 +267,124 @@ async fn canonical_main_exit_transitions_persistent_sandbox_to_error() { delete_sandbox(&sandbox_name).await; } +#[tokio::test] +async fn canonical_main_disconnect_reconnect_replays_history_for_same_process() { + const FIRST_MARKER: &str = "sequence=0001"; + let script = r#"n=1; while true; do printf 'main_pid=%s sequence=%04d\n' "$$" "$n"; n=$((n + 1)); sleep 0.2; done"#; + let mut sandbox = SandboxGuard::create_detached_main(&["sh", "-lc", script]) + .await + .expect("create retained canonical main process"); + + let mut owner_cmd = openshell_cmd(); + owner_cmd + .args(["sandbox", "connect", &sandbox.name]) + .stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + let mut owner = owner_cmd.spawn().expect("spawn input-owning attachment"); + let owner_stdout = owner.stdout.take().expect("owner stdout"); + let mut owner_lines = BufReader::new(owner_stdout).lines(); + let owner_line = tokio::time::timeout(Duration::from_secs(30), owner_lines.next_line()) + .await + .expect("owner output timeout") + .expect("read owner output") + .expect("owner output should remain open"); + assert!( + owner_line.contains("main_pid="), + "unexpected owner output: {owner_line}" + ); + + let mut observer_cmd = openshell_cmd(); + observer_cmd + .args(["sandbox", "connect", &sandbox.name]) + .stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + let mut observer = observer_cmd.spawn().expect("spawn competing attachment"); + let observer_stderr = observer.stderr.take().expect("observer stderr"); + let mut observer_errors = BufReader::new(observer_stderr).lines(); + let warning = tokio::time::timeout(Duration::from_secs(30), observer_errors.next_line()) + .await + .expect("observer warning timeout") + .expect("read observer warning") + .expect("observer warning should remain open"); + assert!( + warning.contains("already has an input owner") && warning.contains("read-only"), + "competing attachment should become read-only: {warning}" + ); + let observer_stdout = observer.stdout.take().expect("observer stdout"); + let mut observer_lines = BufReader::new(observer_stdout).lines(); + let observed = tokio::time::timeout(Duration::from_secs(30), observer_lines.next_line()) + .await + .expect("observer output timeout") + .expect("read observer output") + .expect("observer output should remain open"); + assert!( + observed.contains("main_pid="), + "read-only attachment should observe output: {observed}" + ); + + owner.kill().await.expect("disconnect input owner"); + owner.wait().await.expect("wait for input owner disconnect"); + observer.kill().await.expect("disconnect observer"); + observer.wait().await.expect("wait for observer disconnect"); + sleep(Duration::from_millis(600)).await; + + let mut reconnect_cmd = openshell_cmd(); + reconnect_cmd + .args(["sandbox", "connect", &sandbox.name]) + .stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + let mut reconnect = reconnect_cmd.spawn().expect("spawn reconnect attachment"); + let reconnect_stdout = reconnect.stdout.take().expect("reconnect stdout"); + let mut reconnect_lines = BufReader::new(reconnect_stdout).lines(); + let mut replay = Vec::new(); + tokio::time::timeout(Duration::from_secs(30), async { + while replay.len() < 5 { + let line = reconnect_lines + .next_line() + .await + .expect("read reconnect output") + .expect("reconnect output should remain open"); + if line.contains("main_pid=") { + replay.push(line); + } + } + }) + .await + .expect("reconnect history timeout"); + + let first_pid = owner_line + .split_whitespace() + .find_map(|field| field.strip_prefix("main_pid=")) + .expect("owner output pid"); + assert!( + replay.iter().any(|line| line.contains(FIRST_MARKER)), + "reconnect should replay the beginning of retained history: {replay:?}" + ); + assert!( + replay + .iter() + .all(|line| line.contains(&format!("main_pid={first_pid}"))), + "reconnect should target the same canonical process: {replay:?}" + ); + assert!( + replay.iter().any(|line| !line.contains(FIRST_MARKER)), + "reconnect should observe output beyond the first record: {replay:?}" + ); + + reconnect + .kill() + .await + .expect("disconnect reconnect attachment"); + reconnect + .wait() + .await + .expect("wait for reconnect disconnect"); + sandbox.cleanup().await; +} + #[tokio::test] async fn sandbox_create_with_no_keep_cleans_up_after_tty_command() { let mut cmd = openshell_tty_cmd(&["sandbox", "create", "--no-keep", "--", "echo", "OK"]); From 9d15c3a03a718f43e34a5015ffe431a3679f79e9 Mon Sep 17 00:00:00 2001 From: Drew Newberry Date: Tue, 18 Aug 2026 17:50:44 -0700 Subject: [PATCH 4/8] fix(sandbox): preserve main status across driver updates Signed-off-by: Drew Newberry --- crates/openshell-server/src/compute/mod.rs | 6 ++++++ crates/openshell-supervisor-process/src/process.rs | 10 ++++++++-- 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/crates/openshell-server/src/compute/mod.rs b/crates/openshell-server/src/compute/mod.rs index aa971277a9..33f7adf3e4 100644 --- a/crates/openshell-server/src/compute/mod.rs +++ b/crates/openshell-server/src/compute/mod.rs @@ -3650,6 +3650,12 @@ fn apply_driver_snapshot(sandbox: &mut Sandbox, incoming: &DriverSandbox, sessio { status.sandbox_name.clone_from(sandbox_name); } + if let (Some(status), Some(current_status)) = (status.as_mut(), sandbox.status.as_ref()) { + status + .main_process_instance_id + .clone_from(¤t_status.main_process_instance_id); + status.exit_code = current_status.exit_code; + } if old_phase != phase { info!( sandbox_id = %incoming.id, diff --git a/crates/openshell-supervisor-process/src/process.rs b/crates/openshell-supervisor-process/src/process.rs index 6b3fcdfd00..d211c2c807 100644 --- a/crates/openshell-supervisor-process/src/process.rs +++ b/crates/openshell-supervisor-process/src/process.rs @@ -32,6 +32,12 @@ use std::sync::OnceLock; use tokio::process::{Child, ChildStderr, ChildStdin, ChildStdout, Command}; use tracing::{debug, info}; +// `TIOCSCTTY` is `c_ulong` on Linux but `c_uint` on macOS, while `ioctl` +// accepts `c_ulong` on both platforms. +#[cfg(unix)] +#[allow(trivial_numeric_casts)] +const TIOCSCTTY_REQUEST: libc::c_ulong = libc::TIOCSCTTY as libc::c_ulong; + /// Process/filesystem enforcement performed by the process supervisor. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum ProcessEnforcementMode { @@ -762,7 +768,7 @@ impl ProcessHandle { if libc::setsid() < 0 { return Err(std::io::Error::last_os_error()); } - if libc::ioctl(slave_fd, libc::TIOCSCTTY, 0) < 0 { + if libc::ioctl(slave_fd, TIOCSCTTY_REQUEST, 0) < 0 { return Err(std::io::Error::last_os_error()); } } else { @@ -926,7 +932,7 @@ impl ProcessHandle { if libc::setsid() < 0 { return Err(std::io::Error::last_os_error()); } - if libc::ioctl(slave_fd, libc::TIOCSCTTY, 0) < 0 { + if libc::ioctl(slave_fd, TIOCSCTTY_REQUEST, 0) < 0 { return Err(std::io::Error::last_os_error()); } } else { From c07d8b50b637454ca850d741d6cb6e337094137a Mon Sep 17 00:00:00 2001 From: Drew Newberry Date: Tue, 18 Aug 2026 17:56:07 -0700 Subject: [PATCH 5/8] fix(sandbox): satisfy macOS process lint Signed-off-by: Drew Newberry --- crates/openshell-supervisor-process/src/process.rs | 13 ++++--------- 1 file changed, 4 insertions(+), 9 deletions(-) diff --git a/crates/openshell-supervisor-process/src/process.rs b/crates/openshell-supervisor-process/src/process.rs index d211c2c807..7857683a7a 100644 --- a/crates/openshell-supervisor-process/src/process.rs +++ b/crates/openshell-supervisor-process/src/process.rs @@ -771,11 +771,8 @@ impl ProcessHandle { if libc::ioctl(slave_fd, TIOCSCTTY_REQUEST, 0) < 0 { return Err(std::io::Error::last_os_error()); } - } else { - // Create a distinct process group for signal forwarding. - if libc::setpgid(0, 0) < 0 { - return Err(std::io::Error::last_os_error()); - } + } else if libc::setpgid(0, 0) < 0 { + return Err(std::io::Error::last_os_error()); } // Enter network namespace before applying other restrictions @@ -935,10 +932,8 @@ impl ProcessHandle { if libc::ioctl(slave_fd, TIOCSCTTY_REQUEST, 0) < 0 { return Err(std::io::Error::last_os_error()); } - } else { - if libc::setpgid(0, 0) < 0 { - return Err(std::io::Error::last_os_error()); - } + } else if libc::setpgid(0, 0) < 0 { + return Err(std::io::Error::last_os_error()); } // Drop privileges before applying sandbox restrictions. From 5a281460511db1c1141f80a96fb8c9602071f5be Mon Sep 17 00:00:00 2001 From: Drew Newberry Date: Tue, 18 Aug 2026 18:00:21 -0700 Subject: [PATCH 6/8] fix(sandbox): gate Linux exit acknowledgement publisher Signed-off-by: Drew Newberry --- crates/openshell-sandbox/src/sidecar_control.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/crates/openshell-sandbox/src/sidecar_control.rs b/crates/openshell-sandbox/src/sidecar_control.rs index ce0f20657e..2bd28d5791 100644 --- a/crates/openshell-sandbox/src/sidecar_control.rs +++ b/crates/openshell-sandbox/src/sidecar_control.rs @@ -121,6 +121,7 @@ impl Publisher { }); } + #[cfg(any(target_os = "linux", test))] pub fn publish_main_process_exit_ack(&self, instance_id: String) { let _ = self .updates From a209b62dee592ac9381de40a6b4bbbe687f3dd8d Mon Sep 17 00:00:00 2001 From: Drew Newberry Date: Tue, 18 Aug 2026 19:16:02 -0700 Subject: [PATCH 7/8] refactor(sandbox): simplify main process plumbing Signed-off-by: Drew Newberry --- crates/openshell-core/src/sandbox_env.rs | 3 - crates/openshell-sandbox/src/lib.rs | 2 - crates/openshell-sandbox/src/main.rs | 22 ++---- crates/openshell-sdk/src/types.rs | 11 +-- crates/openshell-server/src/compute/mod.rs | 72 +++++++++++++++---- .../src/supervisor_session.rs | 1 - .../src/main_session.rs | 18 ++--- .../src/process.rs | 10 +-- .../openshell-supervisor-process/src/run.rs | 3 - python/openshell/sandbox.py | 4 -- python/openshell/sandbox_test.py | 2 - .../v1/internal/converter/coverage_test.go | 22 +++--- .../v1/internal/converter/sandbox.go | 1 - .../v1/internal/converter/sandbox_test.go | 1 - sdk/go/openshell/v1/types/sandbox.go | 17 +++-- 15 files changed, 92 insertions(+), 97 deletions(-) diff --git a/crates/openshell-core/src/sandbox_env.rs b/crates/openshell-core/src/sandbox_env.rs index 4e672d4498..7f1b968b1f 100644 --- a/crates/openshell-core/src/sandbox_env.rs +++ b/crates/openshell-core/src/sandbox_env.rs @@ -25,9 +25,6 @@ pub const SSH_SOCKET_PATH: &str = "OPENSHELL_SSH_SOCKET_PATH"; /// Log level for the sandbox supervisor (e.g. `"debug"`, `"info"`, `"warn"`). pub const LOG_LEVEL: &str = "OPENSHELL_LOG_LEVEL"; -/// Shell command to run inside the sandbox. -pub const SANDBOX_COMMAND: &str = "OPENSHELL_SANDBOX_COMMAND"; - /// Versioned JSON specification for the exact canonical main process. pub const MAIN_PROCESS_SPEC: &str = "OPENSHELL_MAIN_PROCESS_SPEC"; diff --git a/crates/openshell-sandbox/src/lib.rs b/crates/openshell-sandbox/src/lib.rs index f26e4e4442..caa9de9994 100644 --- a/crates/openshell-sandbox/src/lib.rs +++ b/crates/openshell-sandbox/src/lib.rs @@ -90,7 +90,6 @@ const SIDECAR_READY_TIMEOUT_SECS: u64 = 120; pub async fn run_sandbox( command: Vec, workdir: Option, - main_workdir: Option, timeout_secs: u64, interactive: bool, sandbox_id: Option, @@ -793,7 +792,6 @@ pub async fn run_sandbox( program, args, workspace, - main_workdir, timeout_secs, interactive, sandbox_id.as_deref(), diff --git a/crates/openshell-sandbox/src/main.rs b/crates/openshell-sandbox/src/main.rs index 61bd941159..8bb168c097 100644 --- a/crates/openshell-sandbox/src/main.rs +++ b/crates/openshell-sandbox/src/main.rs @@ -111,8 +111,7 @@ impl std::str::FromStr for Mode { #[command(about = "Process sandbox and monitor", long_about = None)] struct Args { /// Command to execute in the sandbox. - /// Can also be provided via `OPENSHELL_SANDBOX_COMMAND` environment variable. - /// Defaults to `/bin/bash` if neither is provided. + /// Defaults to `/bin/bash -l` if neither this nor the driver specification is provided. #[arg(trailing_var_arg = true)] command: Vec, @@ -646,22 +645,16 @@ fn main() -> Result<()> { // Resolve an exact canonical process. Explicit offline/test argv wins; // drivers otherwise provide a versioned JSON transport so argument // boundaries are never reconstructed with shell parsing. - let policy_workdir = args.workdir.clone(); - let (command, main_workdir, interactive) = if !args.command.is_empty() { - (args.command, policy_workdir.clone(), args.interactive) + let workdir = args.workdir.clone(); + let (command, interactive) = if !args.command.is_empty() { + (args.command, args.interactive) } else if let Ok(json) = std::env::var(openshell_core::sandbox_env::MAIN_PROCESS_SPEC) { let config = openshell_core::sandbox_env::MainProcessConfig::decode(&json) .map_err(|error| miette::miette!("{error}"))?; - (config.command, policy_workdir.clone(), config.tty) - } else if let Ok(c) = std::env::var(openshell_core::sandbox_env::SANDBOX_COMMAND) { - ( - c.split_whitespace().map(String::from).collect(), - policy_workdir.clone(), - args.interactive, - ) + (config.command, config.tty) } else { let config = openshell_core::sandbox_env::MainProcessConfig::scratch(); - (config.command, policy_workdir.clone(), config.tty) + (config.command, config.tty) }; info!(command = ?command, "Starting sandbox"); @@ -679,8 +672,7 @@ fn main() -> Result<()> { run_sandbox( command, - policy_workdir, - main_workdir, + workdir, args.timeout, interactive, args.sandbox_id, diff --git a/crates/openshell-sdk/src/types.rs b/crates/openshell-sdk/src/types.rs index cdf66c3995..3715c7fdd6 100644 --- a/crates/openshell-sdk/src/types.rs +++ b/crates/openshell-sdk/src/types.rs @@ -125,21 +125,13 @@ pub struct SandboxRef { pub phase: SandboxPhase, pub labels: HashMap, pub resource_version: u64, - pub main_process_instance_id: Option, pub exit_code: Option, } impl SandboxRef { pub(crate) fn from_proto(sandbox: proto::Sandbox) -> Self { let phase = sandbox.phase().into(); - let (main_process_instance_id, exit_code) = - sandbox.status.as_ref().map_or((None, None), |status| { - ( - (!status.main_process_instance_id.is_empty()) - .then(|| status.main_process_instance_id.clone()), - status.exit_code, - ) - }); + let exit_code = sandbox.status.as_ref().and_then(|status| status.exit_code); let meta = sandbox.metadata.unwrap_or_default(); Self { id: meta.id, @@ -148,7 +140,6 @@ impl SandboxRef { phase, labels: meta.labels, resource_version: meta.resource_version, - main_process_instance_id, exit_code, } } diff --git a/crates/openshell-server/src/compute/mod.rs b/crates/openshell-server/src/compute/mod.rs index 33f7adf3e4..c59a4d025a 100644 --- a/crates/openshell-server/src/compute/mod.rs +++ b/crates/openshell-server/src/compute/mod.rs @@ -2821,19 +2821,25 @@ impl ComputeRuntime { if !status.main_process_instance_id.is_empty() && status.main_process_instance_id != instance_id { - return Err(format!( - "stale main-process exit instance '{instance_id}' (active instance is '{}')", - status.main_process_instance_id - )); + tracing::warn!( + sandbox_id, + instance_id, + active_instance_id = %status.main_process_instance_id, + "ignoring stale main-process exit report" + ); + return Ok(()); } if let Some(current_exit_code) = status.exit_code { - return if current_exit_code == exit_code { - Ok(()) - } else { - Err(format!( - "conflicting main-process exit result for instance '{instance_id}'" - )) - }; + if current_exit_code != exit_code { + tracing::warn!( + sandbox_id, + instance_id, + current_exit_code, + reported_exit_code = exit_code, + "ignoring conflicting duplicate main-process exit report" + ); + } + return Ok(()); } } let expected_resource_version = sandbox_resource_version(&existing); @@ -4823,7 +4829,7 @@ mod tests { } #[tokio::test] - async fn stale_main_process_exit_cannot_replace_active_instance() { + async fn stale_main_process_exit_is_acknowledged_without_replacing_active_instance() { let runtime = test_runtime(Arc::new(TestDriver::default())).await; let sandbox = sandbox_record("sb-1", "sandbox-a", SandboxPhase::Provisioning); runtime.store.put_message(&sandbox).await.unwrap(); @@ -4832,11 +4838,10 @@ mod tests { .await .unwrap(); - let error = runtime + runtime .main_process_exited("sb-1", "instance-1", 0) .await - .unwrap_err(); - assert!(error.contains("stale main-process exit instance")); + .unwrap(); let stored = runtime .store .get_message::("sb-1") @@ -4850,6 +4855,16 @@ mod tests { ); } + #[tokio::test] + async fn missing_sandbox_main_process_exit_is_acknowledged() { + let runtime = test_runtime(Arc::new(TestDriver::default())).await; + + runtime + .main_process_exited("missing", "instance-1", 0) + .await + .unwrap(); + } + #[tokio::test] async fn duplicate_main_process_exit_is_idempotent() { let runtime = test_runtime(Arc::new(TestDriver::default())).await; @@ -4877,6 +4892,33 @@ mod tests { assert_eq!(stored.status.unwrap().exit_code, Some(9)); } + #[tokio::test] + async fn conflicting_duplicate_main_process_exit_is_acknowledged() { + let runtime = test_runtime(Arc::new(TestDriver::default())).await; + let sandbox = sandbox_record("sb-1", "sandbox-a", SandboxPhase::Provisioning); + runtime.store.put_message(&sandbox).await.unwrap(); + runtime + .supervisor_session_connected("sb-1", "instance-1") + .await + .unwrap(); + runtime + .main_process_exited("sb-1", "instance-1", 9) + .await + .unwrap(); + runtime + .main_process_exited("sb-1", "instance-1", 7) + .await + .unwrap(); + + let stored = runtime + .store + .get_message::("sb-1") + .await + .unwrap() + .unwrap(); + assert_eq!(stored.status.unwrap().exit_code, Some(9)); + } + #[tokio::test] async fn precise_exit_enriches_driver_terminal_fallback() { let runtime = test_runtime(Arc::new(TestDriver::default())).await; diff --git a/crates/openshell-server/src/supervisor_session.rs b/crates/openshell-server/src/supervisor_session.rs index 748cf9d8bf..fbff0e276c 100644 --- a/crates/openshell-server/src/supervisor_session.rs +++ b/crates/openshell-server/src/supervisor_session.rs @@ -831,7 +831,6 @@ pub async fn handle_report_main_process_exit( if let Some(principal) = principal.as_ref() { crate::auth::guard::ensure_sandbox_principal_scope(principal, &report.sandbox_id)?; } - require_persisted_sandbox(&state.store, &report.sandbox_id).await?; state .compute .main_process_exited(&report.sandbox_id, &report.instance_id, report.exit_code) diff --git a/crates/openshell-supervisor-process/src/main_session.rs b/crates/openshell-supervisor-process/src/main_session.rs index 0e8d42f517..28bd448e02 100644 --- a/crates/openshell-supervisor-process/src/main_session.rs +++ b/crates/openshell-supervisor-process/src/main_session.rs @@ -10,7 +10,7 @@ use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering}; use std::sync::{Arc, Mutex}; use nix::pty::Winsize; -use tokio::io::AsyncReadExt; +use tokio::io::{AsyncReadExt, AsyncWriteExt}; use tokio::sync::Notify; use tokio::sync::broadcast; @@ -46,7 +46,6 @@ pub struct MainSession { pty_master: Option>, readers_remaining: AtomicUsize, readers_done: Notify, - exit_code: Mutex>, } impl MainSession { @@ -65,7 +64,6 @@ impl MainSession { pty_master: None, readers_remaining: AtomicUsize::new(0), readers_done: Notify::new(), - exit_code: Mutex::new(None), }) } @@ -109,7 +107,6 @@ impl MainSession { pty_master, readers_remaining: AtomicUsize::new(if terminal { 1 } else { 2 }), readers_done: Notify::new(), - exit_code: Mutex::new(None), }); Self::start_io(&session, io, input_rx); session @@ -175,16 +172,12 @@ impl MainSession { } stderr_session.reader_finished(); }); - let runtime = tokio::runtime::Handle::current(); - std::thread::spawn(move || { - while let Some(data) = input_rx.blocking_recv() { - if runtime - .block_on(tokio::io::AsyncWriteExt::write_all(&mut stdin, &data)) - .is_err() - { + tokio::spawn(async move { + while let Some(data) = input_rx.recv().await { + if stdin.write_all(&data).await.is_err() { break; } - let _ = runtime.block_on(tokio::io::AsyncWriteExt::flush(&mut stdin)); + let _ = stdin.flush().await; } }); } @@ -221,7 +214,6 @@ impl MainSession { if self.readers_remaining.load(Ordering::Acquire) != 0 { let _ = tokio::time::timeout(std::time::Duration::from_secs(2), notified).await; } - *self.exit_code.lock().expect("main exit lock poisoned") = Some(exit_code); self.publish(MainOutput::Exit(exit_code)); } diff --git a/crates/openshell-supervisor-process/src/process.rs b/crates/openshell-supervisor-process/src/process.rs index 7857683a7a..ee4d48a606 100644 --- a/crates/openshell-supervisor-process/src/process.rs +++ b/crates/openshell-supervisor-process/src/process.rs @@ -579,7 +579,6 @@ impl ProcessHandle { program: &str, args: &[String], workspace: &ResolvedWorkspace, - main_workdir: Option<&str>, interactive: bool, policy: &SandboxPolicy, resolved_identity: ResolvedProcessIdentity, @@ -592,7 +591,6 @@ impl ProcessHandle { program, args, workspace, - main_workdir, interactive, policy, resolved_identity, @@ -614,7 +612,6 @@ impl ProcessHandle { program: &str, args: &[String], workspace: &ResolvedWorkspace, - main_workdir: Option<&str>, interactive: bool, policy: &SandboxPolicy, resolved_identity: ResolvedProcessIdentity, @@ -626,7 +623,6 @@ impl ProcessHandle { program, args, workspace, - main_workdir, interactive, policy, resolved_identity, @@ -642,7 +638,6 @@ impl ProcessHandle { program: &str, args: &[String], workspace: &ResolvedWorkspace, - main_workdir: Option<&str>, interactive: bool, policy: &SandboxPolicy, resolved_identity: ResolvedProcessIdentity, @@ -687,7 +682,7 @@ impl ProcessHandle { inject_provider_env(&mut cmd, provider_env); - if let Some(dir) = main_workdir.or_else(|| workspace.root()) { + if let Some(dir) = workspace.root() { cmd.current_dir(dir); } if let Some(home) = workspace.home() { @@ -841,7 +836,6 @@ impl ProcessHandle { program: &str, args: &[String], workspace: &ResolvedWorkspace, - main_workdir: Option<&str>, interactive: bool, policy: &SandboxPolicy, resolved_identity: ResolvedProcessIdentity, @@ -885,7 +879,7 @@ impl ProcessHandle { inject_provider_env(&mut cmd, provider_env); - if let Some(dir) = main_workdir.or_else(|| workspace.root()) { + if let Some(dir) = workspace.root() { cmd.current_dir(dir); } if let Some(home) = workspace.home() { diff --git a/crates/openshell-supervisor-process/src/run.rs b/crates/openshell-supervisor-process/src/run.rs index 46070da308..34b0001110 100644 --- a/crates/openshell-supervisor-process/src/run.rs +++ b/crates/openshell-supervisor-process/src/run.rs @@ -61,7 +61,6 @@ pub async fn run_process( program: &str, args: &[String], workspace: ResolvedWorkspace, - main_workdir: Option, timeout_secs: u64, interactive: bool, sandbox_id: Option<&str>, @@ -232,7 +231,6 @@ pub async fn run_process( program, args, &workspace, - main_workdir.as_deref(), interactive, policy, resolved_process_identity, @@ -247,7 +245,6 @@ pub async fn run_process( program, args, &workspace, - main_workdir.as_deref(), interactive, policy, resolved_process_identity, diff --git a/python/openshell/sandbox.py b/python/openshell/sandbox.py index 0e20e61024..b66ed936b6 100644 --- a/python/openshell/sandbox.py +++ b/python/openshell/sandbox.py @@ -130,7 +130,6 @@ def _normalize_bearer( class SandboxStatusRef: phase: int current_policy_version: int - main_process_instance_id: str | None = None exit_code: int | None = None @@ -1094,9 +1093,6 @@ def _sandbox_ref(sandbox: openshell_pb2.Sandbox) -> SandboxRef: status=SandboxStatusRef( phase=status.phase if status else 0, current_policy_version=status.current_policy_version if status else 0, - main_process_instance_id=(status.main_process_instance_id or None) - if status - else None, exit_code=status.exit_code if status is not None and status.HasField("exit_code") else None, diff --git a/python/openshell/sandbox_test.py b/python/openshell/sandbox_test.py index 99246aa1c1..a059192460 100644 --- a/python/openshell/sandbox_test.py +++ b/python/openshell/sandbox_test.py @@ -1774,12 +1774,10 @@ def test_sandbox_ref_retains_gateway_labels() -> None: def test_sandbox_ref_includes_main_process_result() -> None: proto = _make_sandbox_proto("sandbox-1", "job-1") - proto.status.main_process_instance_id = "instance-1" proto.status.exit_code = 0 status = _sandbox_ref(proto).status - assert status.main_process_instance_id == "instance-1" assert status.exit_code == 0 diff --git a/sdk/go/openshell/v1/internal/converter/coverage_test.go b/sdk/go/openshell/v1/internal/converter/coverage_test.go index eed0b8731a..49532f59be 100644 --- a/sdk/go/openshell/v1/internal/converter/coverage_test.go +++ b/sdk/go/openshell/v1/internal/converter/coverage_test.go @@ -54,18 +54,20 @@ func TestConverterCoversAllProtoFields_SandboxTemplate(t *testing.T) { func TestConverterCoversAllProtoFields_SandboxStatus(t *testing.T) { handled := fieldSet{ - "sandbox_name": true, - "agent_pod": true, - "agent_fd": true, - "sandbox_fd": true, - "phase": true, - "conditions": true, - "current_policy_version": true, - "main_process_instance_id": true, - "exit_code": true, + "sandbox_name": true, + "agent_pod": true, + "agent_fd": true, + "sandbox_fd": true, + "phase": true, + "conditions": true, + "current_policy_version": true, + "exit_code": true, } + // The instance ID is an internal gateway/supervisor fencing token exposed + // only through the raw protobuf API. + skipped := fieldSet{"main_process_instance_id": true} - assertAllFieldsCovered(t, (&pb.SandboxStatus{}).ProtoReflect().Descriptor(), handled, nil) + assertAllFieldsCovered(t, (&pb.SandboxStatus{}).ProtoReflect().Descriptor(), handled, skipped) } func TestConverterCoversAllProtoFields_SandboxCondition(t *testing.T) { diff --git a/sdk/go/openshell/v1/internal/converter/sandbox.go b/sdk/go/openshell/v1/internal/converter/sandbox.go index ffcdb7d188..5d26a1a7e2 100644 --- a/sdk/go/openshell/v1/internal/converter/sandbox.go +++ b/sdk/go/openshell/v1/internal/converter/sandbox.go @@ -101,7 +101,6 @@ func sandboxStatusFromProto(status *pb.SandboxStatus) types.SandboxStatus { LastTransitionTime: c.GetLastTransitionTime(), }) } - result.MainProcessInstanceID = status.GetMainProcessInstanceId() result.ExitCode = CopyInt32Ptr(status.ExitCode) return result diff --git a/sdk/go/openshell/v1/internal/converter/sandbox_test.go b/sdk/go/openshell/v1/internal/converter/sandbox_test.go index 0e1151cfc1..8293a784c0 100644 --- a/sdk/go/openshell/v1/internal/converter/sandbox_test.go +++ b/sdk/go/openshell/v1/internal/converter/sandbox_test.go @@ -132,7 +132,6 @@ func TestSandboxFromProto(t *testing.T) { assert.Equal(t, "AllGood", s.Status.Conditions[0].Reason) assert.Equal(t, "Sandbox is ready", s.Status.Conditions[0].Message) assert.Equal(t, "2024-01-01T00:00:00Z", s.Status.Conditions[0].LastTransitionTime) - assert.Equal(t, "instance-1", s.Status.MainProcessInstanceID) require.NotNil(t, s.Status.ExitCode) assert.Equal(t, int32(0), *s.Status.ExitCode) } diff --git a/sdk/go/openshell/v1/types/sandbox.go b/sdk/go/openshell/v1/types/sandbox.go index 3ae61246c9..6ce51d84a1 100644 --- a/sdk/go/openshell/v1/types/sandbox.go +++ b/sdk/go/openshell/v1/types/sandbox.go @@ -47,15 +47,14 @@ type SandboxTemplate struct { // SandboxStatus holds the observed state of a sandbox. type SandboxStatus struct { - SandboxName string - AgentPod string - AgentFd string - SandboxFd string - Phase SandboxPhase - Conditions []SandboxCondition - CurrentPolicyVersion uint32 - MainProcessInstanceID string - ExitCode *int32 + SandboxName string + AgentPod string + AgentFd string + SandboxFd string + Phase SandboxPhase + Conditions []SandboxCondition + CurrentPolicyVersion uint32 + ExitCode *int32 } // SandboxCondition describes an observed condition of a sandbox. From 8dde92ed31f6cdcd44769fbe4d6ee71cebffa60d Mon Sep 17 00:00:00 2001 From: Drew Newberry Date: Wed, 19 Aug 2026 10:40:16 -0700 Subject: [PATCH 8/8] fix(supervisor): make controlling tty ioctl portable Signed-off-by: Drew Newberry --- .../src/process.rs | 22 ++++++++++--------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/crates/openshell-supervisor-process/src/process.rs b/crates/openshell-supervisor-process/src/process.rs index ee4d48a606..a94ef4c248 100644 --- a/crates/openshell-supervisor-process/src/process.rs +++ b/crates/openshell-supervisor-process/src/process.rs @@ -32,11 +32,17 @@ use std::sync::OnceLock; use tokio::process::{Child, ChildStderr, ChildStdin, ChildStdout, Command}; use tracing::{debug, info}; -// `TIOCSCTTY` is `c_ulong` on Linux but `c_uint` on macOS, while `ioctl` -// accepts `c_ulong` on both platforms. +// `libc::TIOCSCTTY` and the request parameter accepted by `ioctl` vary across +// glibc, musl, and BSD targets. The conversion is a no-op on some targets but +// is required on others. #[cfg(unix)] -#[allow(trivial_numeric_casts)] -const TIOCSCTTY_REQUEST: libc::c_ulong = libc::TIOCSCTTY as libc::c_ulong; +#[allow(unsafe_code, clippy::useless_conversion)] +fn set_controlling_tty(fd: libc::c_int) -> std::io::Result<()> { + if unsafe { libc::ioctl(fd, libc::TIOCSCTTY.into(), 0) } < 0 { + return Err(std::io::Error::last_os_error()); + } + Ok(()) +} /// Process/filesystem enforcement performed by the process supervisor. #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -763,9 +769,7 @@ impl ProcessHandle { if libc::setsid() < 0 { return Err(std::io::Error::last_os_error()); } - if libc::ioctl(slave_fd, TIOCSCTTY_REQUEST, 0) < 0 { - return Err(std::io::Error::last_os_error()); - } + set_controlling_tty(slave_fd)?; } else if libc::setpgid(0, 0) < 0 { return Err(std::io::Error::last_os_error()); } @@ -923,9 +927,7 @@ impl ProcessHandle { if libc::setsid() < 0 { return Err(std::io::Error::last_os_error()); } - if libc::ioctl(slave_fd, TIOCSCTTY_REQUEST, 0) < 0 { - return Err(std::io::Error::last_os_error()); - } + set_controlling_tty(slave_fd)?; } else if libc::setpgid(0, 0) < 0 { return Err(std::io::Error::last_os_error()); }