From 449a19a04a8117572338f6d8f31297f080f4f889 Mon Sep 17 00:00:00 2001 From: Piotr Mlocek Date: Tue, 10 Nov 2026 17:34:20 -0800 Subject: [PATCH 1/7] build: generate the bindings from core's protos at a pinned release OPENSHELL_CORE_REF in mise.toml pins core v0.1.8. proto:fetch exports the protos at that tag with buf, proto:gen regenerates src/gen, and proto:check fails when the committed bindings are stale. mise.toml implements the repository template's task contract (ci, check, test, build, format, format:check, lint, workflows:check), with Node 24, 22 and 20 locked in mise.lock. Signed-off-by: Piotr Mlocek --- .gitattributes | 1 + .gitignore | 5 +- buf.gen.yaml | 20 +++--- mise.lock | 120 ++++++++++++++++++++++++++++++++ mise.toml | 157 ++++++++++++++++++++++++++++++++++++++++++ scripts/fetch-core.sh | 40 +++++++++++ 6 files changed, 332 insertions(+), 11 deletions(-) create mode 100644 .gitattributes create mode 100644 mise.lock create mode 100644 mise.toml create mode 100755 scripts/fetch-core.sh diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..ddc1cd5 --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +src/gen/** linguist-generated diff --git a/.gitignore b/.gitignore index 63f9dcc..297f473 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,8 @@ node_modules/ -src/gen/ dist/ *.tsbuildinfo .npmrc +coverage/ + +# Core protos fetched at the pinned ref by `mise run proto:fetch`. +/proto/ diff --git a/buf.gen.yaml b/buf.gen.yaml index a0fa6a3..0034a1b 100644 --- a/buf.gen.yaml +++ b/buf.gen.yaml @@ -1,22 +1,22 @@ # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 -# Code generation for the TypeScript SDK. The proto module boundary and -# validation policy live in the repo-level buf.yaml; this template only drives -# generation. buf compiles the module with its own compiler (no protoc) and -# runs the connect-es plugin from this package's devDependencies. Limited to -# the client-surface closure so we don't emit unused compute/test +# Code generation for the TypeScript SDK. `mise run proto:fetch` exports core's +# protos at the pinned ref (OPENSHELL_CORE_REF) into proto/; this template only +# drives generation. buf compiles the module with its own compiler (no protoc) +# and runs the protoc-gen-es plugin from this package's devDependencies. +# Limited to the client-surface closure so we don't emit unused compute/test # protos; well-known types resolve through @bufbuild/protobuf/wkt and are not # generated. version: v2 clean: true inputs: - - directory: ../../proto + - directory: proto paths: - - ../../proto/openshell.proto - - ../../proto/sandbox.proto - - ../../proto/datamodel.proto - - ../../proto/options.proto + - proto/openshell.proto + - proto/sandbox.proto + - proto/datamodel.proto + - proto/options.proto # Standard rich gRPC error messages, pinned to an immutable Google APIs commit. - module: buf.build/googleapis/googleapis:c17df5b2beca46928cc87d5656bd5343 paths: diff --git a/mise.lock b/mise.lock new file mode 100644 index 0000000..d86a385 --- /dev/null +++ b/mise.lock @@ -0,0 +1,120 @@ +# @generated - this file is auto-generated by `mise lock` https://mise.jdx.dev/dev-tools/mise-lock.html + +lockfile_version = 2 + +[[tools.actionlint]] +version = "1.7.12" +backend = "aqua:rhysd/actionlint" +specifiers = ["1.7.12"] + +[tools.actionlint."platforms.linux-arm64"] +checksum = "sha256:325e971b6ba9bfa504672e29be93c24981eeb1c07576d730e9f7c8805afff0c6" +url = "https://github.com/rhysd/actionlint/releases/download/v1.7.12/actionlint_1.7.12_linux_arm64.tar.gz" +url_api = "https://api.github.com/repos/rhysd/actionlint/releases/assets/384924897" +provenance = "github-attestations" + +[tools.actionlint."platforms.linux-x64"] +checksum = "sha256:8aca8db96f1b94770f1b0d72b6dddcb1ebb8123cb3712530b08cc387b349a3d8" +url = "https://github.com/rhysd/actionlint/releases/download/v1.7.12/actionlint_1.7.12_linux_amd64.tar.gz" +url_api = "https://api.github.com/repos/rhysd/actionlint/releases/assets/384924896" +provenance = "github-attestations" + +[tools.actionlint."platforms.macos-arm64"] +checksum = "sha256:aba9ced2dee8d27fecca3dc7feb1a7f9a52caefa1eb46f3271ea66b6e0e6953f" +url = "https://github.com/rhysd/actionlint/releases/download/v1.7.12/actionlint_1.7.12_darwin_arm64.tar.gz" +url_api = "https://api.github.com/repos/rhysd/actionlint/releases/assets/384924893" +provenance = "github-attestations" + +[[tools.node]] +version = "20.20.2" +backend = "core:node" +specifiers = ["20.20.2"] + +[tools.node."platforms.linux-arm64"] +checksum = "sha256:47ef73d543ecf6eb19435f6c03a0ac4809b3bf0dd6b26c7c571efc2a6572a74d" +url = "https://nodejs.org/dist/v20.20.2/node-v20.20.2-linux-arm64.tar.gz" + +[tools.node."platforms.linux-x64"] +checksum = "sha256:19e56f0825510207dd904f087fe52faa0a4eb6b2aab5f0ea7a33830d04888b8b" +url = "https://nodejs.org/dist/v20.20.2/node-v20.20.2-linux-x64.tar.gz" + +[tools.node."platforms.macos-arm64"] +checksum = "sha256:466e05f3477c20dfb723054dfebffe55bc74660ee77f612166fca121dacb65b6" +url = "https://nodejs.org/dist/v20.20.2/node-v20.20.2-darwin-arm64.tar.gz" + +[[tools.node]] +version = "22.23.4" +backend = "core:node" +specifiers = ["22.23.4"] + +[tools.node."platforms.linux-arm64"] +checksum = "sha256:f7a1e486dbc8b286847815b477d4fb5e9fb963ed4489c3e1588853d685f589f9" +url = "https://nodejs.org/dist/v22.23.4/node-v22.23.4-linux-arm64.tar.gz" + +[tools.node."platforms.linux-x64"] +checksum = "sha256:b8492284c76a54baf58d61668dd0e41ee0fc98adabf9503d30f05d08f55b4406" +url = "https://nodejs.org/dist/v22.23.4/node-v22.23.4-linux-x64.tar.gz" + +[tools.node."platforms.macos-arm64"] +checksum = "sha256:c9e1dbc748b33ed2d14f42445191ecaf14c56259c7a9a26d0042c49ec2b66428" +url = "https://nodejs.org/dist/v22.23.4/node-v22.23.4-darwin-arm64.tar.gz" + +[[tools.node]] +version = "24.22.2" +backend = "core:node" +specifiers = ["24.22.2"] + +[tools.node."platforms.linux-arm64"] +checksum = "sha256:95c264150aceb7f3437a29fd6984924f5f8d1511ea3cbd6c508b83f6c555dae2" +url = "https://nodejs.org/dist/v24.22.2/node-v24.22.2-linux-arm64.tar.gz" + +[tools.node."platforms.linux-x64"] +checksum = "sha256:361718c444e49af2ca5a110c83ba6a8901143f23ab285ebbef0341f391f482a9" +url = "https://nodejs.org/dist/v24.22.2/node-v24.22.2-linux-x64.tar.gz" + +[tools.node."platforms.macos-arm64"] +checksum = "sha256:aa9549349e47dffaa42dcf95d6e06ade8c4bdafc980979883b88767670df385a" +url = "https://nodejs.org/dist/v24.22.2/node-v24.22.2-darwin-arm64.tar.gz" + +[[tools.shellcheck]] +version = "0.11.0" +backend = "aqua:koalaman/shellcheck" +specifiers = ["0.11.0"] + +[tools.shellcheck."platforms.linux-arm64"] +checksum = "sha256:12b331c1d2db6b9eb13cfca64306b1b157a86eb69db83023e261eaa7e7c14588" +url = "https://github.com/koalaman/shellcheck/releases/download/v0.11.0/shellcheck-v0.11.0.linux.aarch64.tar.xz" +url_api = "https://api.github.com/repos/koalaman/shellcheck/releases/assets/279056934" + +[tools.shellcheck."platforms.linux-x64"] +checksum = "sha256:8c3be12b05d5c177a04c29e3c78ce89ac86f1595681cab149b65b97c4e227198" +url = "https://github.com/koalaman/shellcheck/releases/download/v0.11.0/shellcheck-v0.11.0.linux.x86_64.tar.xz" +url_api = "https://api.github.com/repos/koalaman/shellcheck/releases/assets/279056942" + +[tools.shellcheck."platforms.macos-arm64"] +checksum = "sha256:56affdd8de5527894dca6dc3d7e0a99a873b0f004d7aabc30ae407d3f48b0a79" +url = "https://github.com/koalaman/shellcheck/releases/download/v0.11.0/shellcheck-v0.11.0.darwin.aarch64.tar.xz" +url_api = "https://api.github.com/repos/koalaman/shellcheck/releases/assets/279056932" + +[[tools.zizmor]] +version = "1.32.0" +backend = "aqua:zizmorcore/zizmor" +specifiers = ["1.32.0"] + +[tools.zizmor."platforms.linux-arm64"] +checksum = "sha256:cb152b207f815116d7fa1c1ee4614f61578803351395052908095e79adfd9fd0" +url = "https://github.com/zizmorcore/zizmor/releases/download/v1.32.0/zizmor-aarch64-unknown-linux-gnu.tar.gz" +url_api = "https://api.github.com/repos/zizmorcore/zizmor/releases/assets/703541931" +provenance = "github-attestations" + +[tools.zizmor."platforms.linux-x64"] +checksum = "sha256:bb110cc765eca9cd7efb2e284a956be5974c60027b0970f16397d86208a9957b" +url = "https://github.com/zizmorcore/zizmor/releases/download/v1.32.0/zizmor-x86_64-unknown-linux-gnu.tar.gz" +url_api = "https://api.github.com/repos/zizmorcore/zizmor/releases/assets/703541932" +provenance = "github-attestations" + +[tools.zizmor."platforms.macos-arm64"] +checksum = "sha256:6efed18c4539a663fd3c851a2be9533fd8456c4e646d9416206da059154a0d3c" +url = "https://github.com/zizmorcore/zizmor/releases/download/v1.32.0/zizmor-aarch64-apple-darwin.tar.gz" +url_api = "https://api.github.com/repos/zizmorcore/zizmor/releases/assets/703541933" +provenance = "github-attestations" diff --git a/mise.toml b/mise.toml new file mode 100644 index 0000000..483fd23 --- /dev/null +++ b/mise.toml @@ -0,0 +1,157 @@ +# SPDX-License-Identifier: Apache-2.0 + +# TypeScript SDK tasks. Run `mise tasks` to list them and `mise run ci` for the +# full pipeline. Bindings are generated from core's proto/ at the ref pinned in +# OPENSHELL_CORE_REF and committed under src/gen, so building the package needs +# no core checkout and no network beyond `npm ci`. +# +# The tasks marked "contract" are called by name from the repository +# template's workflows (pimlock/openshell-repo-template). Keep their names; +# change what they run. + +min_version = { soft = "2026.9.9" } + +# Tools are locked in mise.lock; CI installs with `mise install --locked`. +# Run `mise lock` after changing [tools]. +[settings] +lockfile = true +lockfile_platforms = ["linux-x64", "linux-arm64", "macos-arm64"] + +[tools] +# The first Node version is the default. The others are the older releases +# that package.json's engines field supports; CI runs the unit tests on each +# by setting MISE_NODE_VERSION. +node = ["24.22.2", "22.23.4", "20.20.2"] +actionlint = "1.7.12" +shellcheck = "0.11.0" +zizmor = "1.32.0" + +[env] +# The single core pin: a release tag. +OPENSHELL_CORE_REF = "v0.1.8" + +# --- Contract tasks --------------------------------------------------------- + +[tasks.ci] +description = "Run the full CI pipeline (contract)" +depends = ["check", "test", "build"] + +[tasks.check] +description = "Run formatting, lint, type, and drift checks (contract)" +depends = ["format:check", "lint", "typecheck", "proto:check", "vendored:check"] + +[tasks.test] +description = "Run unit tests with an 80% line-coverage gate (contract)" +depends = ["install"] +run = "npm test" + +[tasks.build] +description = "Build dist/ and verify the package contents (contract)" +depends = ["install"] +run = """ +#!/usr/bin/env bash +set -euo pipefail +rm -rf dist +npm run build +# The files npm would publish: both entry points and their declarations, and +# no tests or sources. +files=$(npm pack --dry-run --json | node -e ' + let s = ""; process.stdin.on("data", (d) => (s += d)).on("end", () => { + for (const f of JSON.parse(s)[0].files) console.log(f.path); + });') +for f in dist/index.js dist/index.d.ts dist/raw.js dist/raw.d.ts dist/gen/openshell_pb.js README.md package.json; do + grep -qx "$f" <<<"$files" || { echo "ERROR: the package is missing $f" >&2; exit 1; } +done +if grep -E '\\.test\\.|^src/' <<<"$files"; then + echo "ERROR: the package contains tests or sources" >&2 + exit 1 +fi +echo "package: $(wc -l <<<"$files" | tr -d ' ') files" +""" + +[tasks.format] +description = "Format the code and apply safe fixes (contract)" +depends = ["install"] +run = "npm run format" + +[tasks."format:check"] +description = "Check formatting (contract)" +depends = ["install"] +run = "npx --no-install biome format ." + +[tasks.lint] +description = "Lint the code and check formatting (contract)" +depends = ["install"] +run = "npm run lint" + +[tasks."workflows:check"] +description = "Lint GitHub workflows (actionlint with shellcheck, zizmor) and shell scripts (contract)" +run = [ + "actionlint", + "zizmor --offline --min-severity medium .github", + "shellcheck -x -S warning scripts/*.sh", +] + +# --- Repository tasks ------------------------------------------------------- + +[tasks."core:version"] +description = "Print the pinned core ref" +run = "echo $OPENSHELL_CORE_REF" + +[tasks.install] +description = "Install the npm dependencies from package-lock.json" +run = "npm ci --no-audit --no-fund" +sources = ["package.json", "package-lock.json"] +outputs = ["node_modules/.package-lock.json"] + +[tasks.typecheck] +description = "Type-check the SDK" +depends = ["install"] +run = "npm run typecheck" + +[tasks."proto:fetch"] +description = "Export the SDK's protos from core at the pinned ref into proto/" +depends = ["install"] +# buf follows the imports of the root files, so proto/ holds exactly the files +# the SDK compiles. buf comes from the package's devDependencies. +run = """ +#!/usr/bin/env bash +set -euo pipefail +rm -rf proto +npx --no-install buf export "https://github.com/NVIDIA/OpenShell.git#ref=${OPENSHELL_CORE_REF},depth=1,subdir=proto" \ + --path openshell.proto --path sandbox.proto --path datamodel.proto --path options.proto \ + --output proto +""" + +[tasks."proto:gen"] +description = "Generate the protobuf bindings into src/gen" +depends = ["install", "proto:fetch"] +run = "npm run gen" + +[tasks."proto:check"] +description = "Fail if the committed bindings differ from the pinned protos" +depends = ["proto:gen"] +run = """ +#!/usr/bin/env bash +set -euo pipefail +if ! git diff --exit-code --stat -- src/gen \ + || [ -n "$(git ls-files --others --exclude-standard -- src/gen)" ]; then + echo "ERROR: src/gen is stale; run 'mise run proto:gen' and commit." >&2 + exit 1 +fi +""" + +[tasks."vendored:check"] +description = "Fail if a file copied from core (scripts/vendored-core-files.txt) differs from core at the pinned ref" +run = """ +#!/usr/bin/env bash +set -euo pipefail +core=$(mktemp -d) +trap 'rm -rf "$core"' EXIT +files=$(grep -v '^#' scripts/vendored-core-files.txt) +# shellcheck disable=SC2046 # one argument per core path +scripts/fetch-core.sh "$OPENSHELL_CORE_REF" "$core" $(awk '{ print $1 }' <<<"$files") +while read -r src dst; do + diff -u "$core/$src" "$dst" +done <<<"$files" +""" diff --git a/scripts/fetch-core.sh b/scripts/fetch-core.sh new file mode 100755 index 0000000..46dd554 --- /dev/null +++ b/scripts/fetch-core.sh @@ -0,0 +1,40 @@ +#!/usr/bin/env bash +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +# fetch-core.sh: copy files from NVIDIA/OpenShell at a pinned ref. +# +# The protos come from `buf export` (mise run proto:fetch); this script fetches +# the other core files the repository checks against, such as the vendored +# conformance fixtures. +# +# Usage: fetch-core.sh ... +# +# Fetches only (a tag or a full commit SHA), without history or unneeded +# blobs, and copies each (a file or directory) into +# under the same relative path, replacing what was there. +set -euo pipefail + +if [ $# -lt 3 ]; then + echo "usage: $0 ..." >&2 + exit 2 +fi + +ref=$1 +out=$2 +shift 2 +remote=${OPENSHELL_CORE_REMOTE:-https://github.com/NVIDIA/OpenShell.git} +work=$(mktemp -d) +trap 'rm -rf "$work"' EXIT + +git -C "$work" init --quiet +git -C "$work" remote add origin "$remote" +git -C "$work" fetch --quiet --depth 1 --filter=blob:none --no-tags origin "$ref" +git -C "$work" sparse-checkout set --no-cone "$@" +git -C "$work" checkout --quiet FETCH_HEAD + +for path in "$@"; do + rm -rf "${out:?}/$path" + mkdir -p "$out/$(dirname "$path")" + cp -R "$work/$path" "$out/$path" +done From d4d20d47fbfd545f943fbd0e2f3abf7ba047b797 Mon Sep 17 00:00:00 2001 From: Piotr Mlocek Date: Tue, 10 Nov 2026 17:34:20 -0800 Subject: [PATCH 2/7] build: commit the generated bindings Generated by mise run proto:gen at core v0.1.8; byte-identical to what core's sdk:ts:proto generates at that tag. .gitattributes marks them generated. Signed-off-by: Piotr Mlocek --- src/gen/datamodel_pb.ts | 339 + src/gen/google/rpc/error_details_pb.ts | 662 ++ src/gen/openshell_pb.ts | 11926 +++++++++++++++++++++++ src/gen/options_pb.ts | 80 + src/gen/sandbox_pb.ts | 1639 ++++ 5 files changed, 14646 insertions(+) create mode 100644 src/gen/datamodel_pb.ts create mode 100644 src/gen/google/rpc/error_details_pb.ts create mode 100644 src/gen/openshell_pb.ts create mode 100644 src/gen/options_pb.ts create mode 100644 src/gen/sandbox_pb.ts diff --git a/src/gen/datamodel_pb.ts b/src/gen/datamodel_pb.ts new file mode 100644 index 0000000..c1c9e0b --- /dev/null +++ b/src/gen/datamodel_pb.ts @@ -0,0 +1,339 @@ +// SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +// @generated by protoc-gen-es v2.12.1 with parameter "target=ts,import_extension=js" +// @generated from file datamodel.proto (package openshell.datamodel.v1, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2"; +import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv2"; +import { file_options } from "./options_pb.js"; +import type { Timestamp } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file datamodel.proto. + */ +export const file_datamodel: GenFile = /*@__PURE__*/ + fileDesc("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", [file_options, file_google_protobuf_timestamp]); + +/** + * Selects the workspace scope for a public API request. + * + * Requests that operate on one workspace require a non-empty `workspace`. + * Cross-workspace list requests additionally accept `all_workspaces`. The + * containing request documents which selections it supports; an omitted + * selector is invalid for workspace-scoped operations. + * + * @generated from message openshell.datamodel.v1.WorkspaceSelector + */ +export type WorkspaceSelector = Message<"openshell.datamodel.v1.WorkspaceSelector"> & { + /** + * @generated from oneof openshell.datamodel.v1.WorkspaceSelector.selection + */ + selection: { + /** + * One explicitly named workspace. Use `default` to select the gateway's + * default workspace; an empty name is invalid. + * + * @generated from field: string workspace = 1; + */ + value: string; + case: "workspace"; + } | { + /** + * All workspaces the caller is authorized to access. Only supported by + * requests that explicitly document cross-workspace behavior. + * + * @generated from field: openshell.datamodel.v1.AllWorkspaces all_workspaces = 2; + */ + value: AllWorkspaces; + case: "allWorkspaces"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message openshell.datamodel.v1.WorkspaceSelector. + * Use `create(WorkspaceSelectorSchema)` to create a new message. + */ +export const WorkspaceSelectorSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_datamodel, 0); + +/** + * Marker for the all-workspaces selector variant. + * + * @generated from message openshell.datamodel.v1.AllWorkspaces + */ +export type AllWorkspaces = Message<"openshell.datamodel.v1.AllWorkspaces"> & { +}; + +/** + * Describes the message openshell.datamodel.v1.AllWorkspaces. + * Use `create(AllWorkspacesSchema)` to create a new message. + */ +export const AllWorkspacesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_datamodel, 1); + +/** + * Kubernetes-style metadata shared by all top-level OpenShell domain objects. + * + * This structure provides consistent metadata (identity, labels, annotations, + * timestamps, resource versioning) across Sandbox, Provider, SshSession, and + * other resources. + * + * @generated from message openshell.datamodel.v1.ObjectMeta + */ +export type ObjectMeta = Message<"openshell.datamodel.v1.ObjectMeta"> & { + /** + * Stable object ID generated by the gateway. + * + * @generated from field: string id = 1; + */ + id: string; + + /** + * Human-readable object name (unique per object type). + * + * @generated from field: string name = 2; + */ + name: string; + + /** + * Time when the object was created. + * + * @generated from field: google.protobuf.Timestamp created_time = 103; + */ + createdTime?: Timestamp | undefined; + + /** + * Key-value labels for filtering and organization. + * Labels must follow Kubernetes conventions: alphanumeric + `-._/`, max 63 chars per segment. + * + * @generated from field: map labels = 4; + */ + labels: { [key: string]: string }; + + /** + * Optimistic concurrency control version. + * Incremented by the gateway on each update. Clients can use this for compare-and-swap operations. + * + * @generated from field: uint64 resource_version = 5; + */ + resourceVersion: bigint; + + /** + * Opaque key-value metadata that is not used for selectors. + * Annotation keys use the same qualified-key shape as labels, but values may be longer. + * + * @generated from field: map annotations = 6; + */ + annotations: { [key: string]: string }; + + /** + * Workspace that owns this resource. Empty is normalized to "default" by the + * gateway. Immutable after creation. + * + * @generated from field: string workspace = 7; + */ + workspace: string; + + /** + * Time when graceful deletion was initiated. Absence means the object is + * not being deleted. Once set, this field is + * immutable — the only path forward is completing deletion. + * + * @generated from field: google.protobuf.Timestamp deletion_time = 108; + */ + deletionTime?: Timestamp | undefined; +}; + +/** + * Describes the message openshell.datamodel.v1.ObjectMeta. + * Use `create(ObjectMetaSchema)` to create a new message. + */ +export const ObjectMetaSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_datamodel, 2); + +/** + * Status of a workspace. + * + * @generated from message openshell.datamodel.v1.WorkspaceStatus + */ +export type WorkspaceStatus = Message<"openshell.datamodel.v1.WorkspaceStatus"> & { + /** + * @generated from field: openshell.datamodel.v1.WorkspacePhase phase = 1; + */ + phase: WorkspacePhase; +}; + +/** + * Describes the message openshell.datamodel.v1.WorkspaceStatus. + * Use `create(WorkspaceStatusSchema)` to create a new message. + */ +export const WorkspaceStatusSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_datamodel, 3); + +/** + * Workspace resource. A hard isolation boundary for sandboxes, providers, and + * other workspace-scoped resources. + * + * @generated from message openshell.datamodel.v1.Workspace + */ +export type Workspace = Message<"openshell.datamodel.v1.Workspace"> & { + /** + * Kubernetes-style metadata (id, name, labels, timestamps, resource version). + * The workspace field in this ObjectMeta is unused (a workspace does not + * belong to another workspace). + * + * @generated from field: openshell.datamodel.v1.ObjectMeta metadata = 1; + */ + metadata?: ObjectMeta | undefined; + + /** + * Current lifecycle status. + * + * @generated from field: openshell.datamodel.v1.WorkspaceStatus status = 2; + */ + status?: WorkspaceStatus | undefined; +}; + +/** + * Describes the message openshell.datamodel.v1.Workspace. + * Use `create(WorkspaceSchema)` to create a new message. + */ +export const WorkspaceSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_datamodel, 4); + +/** + * Opaque handle for a provider credential stored by gateway credential storage. + * Handles are created by OpenShell and must not be authored by users. + * + * @generated from message openshell.datamodel.v1.CredentialHandle + */ +export type CredentialHandle = Message<"openshell.datamodel.v1.CredentialHandle"> & { + /** + * Internal storage owner or credential driver that owns this handle. + * + * @generated from field: string driver = 1; + */ + driver: string; + + /** + * Owner-owned opaque handle string. + * + * @generated from field: string handle = 2; + */ + handle: string; + + /** + * Owner-owned non-secret metadata. + * + * @generated from field: map metadata = 3; + */ + metadata: { [key: string]: string }; +}; + +/** + * Describes the message openshell.datamodel.v1.CredentialHandle. + * Use `create(CredentialHandleSchema)` to create a new message. + */ +export const CredentialHandleSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_datamodel, 5); + +/** + * Provider model stored by OpenShell. + * + * @generated from message openshell.datamodel.v1.Provider + */ +export type Provider = Message<"openshell.datamodel.v1.Provider"> & { + /** + * Kubernetes-style metadata (id, name, labels, timestamps, resource version). + * + * @generated from field: openshell.datamodel.v1.ObjectMeta metadata = 1; + */ + metadata?: ObjectMeta | undefined; + + /** + * ID of the provider profile this provider was created from, matched + * exactly (for example: "claude-code", "github"). + * + * @generated from field: string type = 2; + */ + type: string; + + /** + * Secret values used for authentication. + * + * @generated from field: map credentials = 3; + */ + credentials: { [key: string]: string }; + + /** + * Non-secret provider configuration. + * + * @generated from field: map config = 4; + */ + config: { [key: string]: string }; + + /** + * Expiration times for credential values, keyed by credential/env var name. + * A missing key means the credential does not expire. + * + * @generated from field: map credential_expiration_times = 105; + */ + credentialExpirationTimes: { [key: string]: Timestamp }; + + /** + * Workspace where this provider's type profile is stored. + * Empty string = platform/global scope. Must be empty or match + * metadata.workspace; cross-workspace references are rejected. + * + * @generated from field: string profile_workspace = 6; + */ + profileWorkspace: string; + + /** + * Opaque handles for secret values stored through gateway credential storage. + * This map is internal gateway state and is not accepted as user-authored input. + * + * @generated from field: map credential_handles = 7; + */ + credentialHandles: { [key: string]: CredentialHandle }; +}; + +/** + * Describes the message openshell.datamodel.v1.Provider. + * Use `create(ProviderSchema)` to create a new message. + */ +export const ProviderSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_datamodel, 6); + +/** + * Phase of a workspace's lifecycle. + * + * @generated from enum openshell.datamodel.v1.WorkspacePhase + */ +export enum WorkspacePhase { + /** + * @generated from enum value: WORKSPACE_PHASE_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: WORKSPACE_PHASE_ACTIVE = 1; + */ + ACTIVE = 1, + + /** + * @generated from enum value: WORKSPACE_PHASE_TERMINATING = 2; + */ + TERMINATING = 2, +} + +/** + * Describes the enum openshell.datamodel.v1.WorkspacePhase. + */ +export const WorkspacePhaseSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_datamodel, 0); + diff --git a/src/gen/google/rpc/error_details_pb.ts b/src/gen/google/rpc/error_details_pb.ts new file mode 100644 index 0000000..acf7a6c --- /dev/null +++ b/src/gen/google/rpc/error_details_pb.ts @@ -0,0 +1,662 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// @generated by protoc-gen-es v2.12.1 with parameter "target=ts,import_extension=js" +// @generated from file google/rpc/error_details.proto (package google.rpc, syntax proto3) +/* eslint-disable */ + +import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2"; +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv2"; +import type { Duration } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_duration } from "@bufbuild/protobuf/wkt"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file google/rpc/error_details.proto. + */ +export const file_google_rpc_error_details: GenFile = /*@__PURE__*/ + fileDesc("Ch5nb29nbGUvcnBjL2Vycm9yX2RldGFpbHMucHJvdG8SCmdvb2dsZS5ycGMikwEKCUVycm9ySW5mbxIOCgZyZWFzb24YASABKAkSDgoGZG9tYWluGAIgASgJEjUKCG1ldGFkYXRhGAMgAygLMiMuZ29vZ2xlLnJwYy5FcnJvckluZm8uTWV0YWRhdGFFbnRyeRovCg1NZXRhZGF0YUVudHJ5EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgCIAEoCToCOAEiOwoJUmV0cnlJbmZvEi4KC3JldHJ5X2RlbGF5GAEgASgLMhkuZ29vZ2xlLnByb3RvYnVmLkR1cmF0aW9uIjIKCURlYnVnSW5mbxIVCg1zdGFja19lbnRyaWVzGAEgAygJEg4KBmRldGFpbBgCIAEoCSKPAwoMUXVvdGFGYWlsdXJlEjYKCnZpb2xhdGlvbnMYASADKAsyIi5nb29nbGUucnBjLlF1b3RhRmFpbHVyZS5WaW9sYXRpb24axgIKCVZpb2xhdGlvbhIPCgdzdWJqZWN0GAEgASgJEhMKC2Rlc2NyaXB0aW9uGAIgASgJEhMKC2FwaV9zZXJ2aWNlGAMgASgJEhQKDHF1b3RhX21ldHJpYxgEIAEoCRIQCghxdW90YV9pZBgFIAEoCRJRChBxdW90YV9kaW1lbnNpb25zGAYgAygLMjcuZ29vZ2xlLnJwYy5RdW90YUZhaWx1cmUuVmlvbGF0aW9uLlF1b3RhRGltZW5zaW9uc0VudHJ5EhMKC3F1b3RhX3ZhbHVlGAcgASgDEh8KEmZ1dHVyZV9xdW90YV92YWx1ZRgIIAEoA0gAiAEBGjYKFFF1b3RhRGltZW5zaW9uc0VudHJ5EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgCIAEoCToCOAFCFQoTX2Z1dHVyZV9xdW90YV92YWx1ZSKVAQoTUHJlY29uZGl0aW9uRmFpbHVyZRI9Cgp2aW9sYXRpb25zGAEgAygLMikuZ29vZ2xlLnJwYy5QcmVjb25kaXRpb25GYWlsdXJlLlZpb2xhdGlvbho/CglWaW9sYXRpb24SDAoEdHlwZRgBIAEoCRIPCgdzdWJqZWN0GAIgASgJEhMKC2Rlc2NyaXB0aW9uGAMgASgJIswBCgpCYWRSZXF1ZXN0Ej8KEGZpZWxkX3Zpb2xhdGlvbnMYASADKAsyJS5nb29nbGUucnBjLkJhZFJlcXVlc3QuRmllbGRWaW9sYXRpb24afQoORmllbGRWaW9sYXRpb24SDQoFZmllbGQYASABKAkSEwoLZGVzY3JpcHRpb24YAiABKAkSDgoGcmVhc29uGAMgASgJEjcKEWxvY2FsaXplZF9tZXNzYWdlGAQgASgLMhwuZ29vZ2xlLnJwYy5Mb2NhbGl6ZWRNZXNzYWdlIjcKC1JlcXVlc3RJbmZvEhIKCnJlcXVlc3RfaWQYASABKAkSFAoMc2VydmluZ19kYXRhGAIgASgJImAKDFJlc291cmNlSW5mbxIVCg1yZXNvdXJjZV90eXBlGAEgASgJEhUKDXJlc291cmNlX25hbWUYAiABKAkSDQoFb3duZXIYAyABKAkSEwoLZGVzY3JpcHRpb24YBCABKAkiVgoESGVscBIkCgVsaW5rcxgBIAMoCzIVLmdvb2dsZS5ycGMuSGVscC5MaW5rGigKBExpbmsSEwoLZGVzY3JpcHRpb24YASABKAkSCwoDdXJsGAIgASgJIjMKEExvY2FsaXplZE1lc3NhZ2USDgoGbG9jYWxlGAEgASgJEg8KB21lc3NhZ2UYAiABKAlCbAoOY29tLmdvb2dsZS5ycGNCEUVycm9yRGV0YWlsc1Byb3RvUAFaP2dvb2dsZS5nb2xhbmcub3JnL2dlbnByb3RvL2dvb2dsZWFwaXMvcnBjL2VycmRldGFpbHM7ZXJyZGV0YWlsc6ICA1JQQ2IGcHJvdG8z", [file_google_protobuf_duration]); + +/** + * Describes the cause of the error with structured details. + * + * Example of an error when contacting the "pubsub.googleapis.com" API when it + * is not enabled: + * + * { "reason": "API_DISABLED" + * "domain": "googleapis.com" + * "metadata": { + * "resource": "projects/123", + * "service": "pubsub.googleapis.com" + * } + * } + * + * This response indicates that the pubsub.googleapis.com API is not enabled. + * + * Example of an error that is returned when attempting to create a Spanner + * instance in a region that is out of stock: + * + * { "reason": "STOCKOUT" + * "domain": "spanner.googleapis.com", + * "metadata": { + * "availableRegions": "us-central1,us-east2" + * } + * } + * + * @generated from message google.rpc.ErrorInfo + */ +export type ErrorInfo = Message<"google.rpc.ErrorInfo"> & { + /** + * The reason of the error. This is a constant value that identifies the + * proximate cause of the error. Error reasons are unique within a particular + * domain of errors. This should be at most 63 characters and match a + * regular expression of `[A-Z][A-Z0-9_]+[A-Z0-9]`, which represents + * UPPER_SNAKE_CASE. + * + * @generated from field: string reason = 1; + */ + reason: string; + + /** + * The logical grouping to which the "reason" belongs. The error domain + * is typically the registered service name of the tool or product that + * generates the error. Example: "pubsub.googleapis.com". If the error is + * generated by some common infrastructure, the error domain must be a + * globally unique value that identifies the infrastructure. For Google API + * infrastructure, the error domain is "googleapis.com". + * + * @generated from field: string domain = 2; + */ + domain: string; + + /** + * Additional structured details about this error. + * + * Keys must match a regular expression of `[a-z][a-zA-Z0-9-_]+` but should + * ideally be lowerCamelCase. Also, they must be limited to 64 characters in + * length. When identifying the current value of an exceeded limit, the units + * should be contained in the key, not the value. For example, rather than + * `{"instanceLimit": "100/request"}`, should be returned as, + * `{"instanceLimitPerRequest": "100"}`, if the client exceeds the number of + * instances that can be created in a single (batch) request. + * + * @generated from field: map metadata = 3; + */ + metadata: { [key: string]: string }; +}; + +/** + * Describes the message google.rpc.ErrorInfo. + * Use `create(ErrorInfoSchema)` to create a new message. + */ +export const ErrorInfoSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_google_rpc_error_details, 0); + +/** + * Describes when the clients can retry a failed request. Clients could ignore + * the recommendation here or retry when this information is missing from error + * responses. + * + * It's always recommended that clients should use exponential backoff when + * retrying. + * + * Clients should wait until `retry_delay` amount of time has passed since + * receiving the error response before retrying. If retrying requests also + * fail, clients should use an exponential backoff scheme to gradually increase + * the delay between retries based on `retry_delay`, until either a maximum + * number of retries have been reached or a maximum retry delay cap has been + * reached. + * + * @generated from message google.rpc.RetryInfo + */ +export type RetryInfo = Message<"google.rpc.RetryInfo"> & { + /** + * Clients should wait at least this long between retrying the same request. + * + * @generated from field: google.protobuf.Duration retry_delay = 1; + */ + retryDelay?: Duration | undefined; +}; + +/** + * Describes the message google.rpc.RetryInfo. + * Use `create(RetryInfoSchema)` to create a new message. + */ +export const RetryInfoSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_google_rpc_error_details, 1); + +/** + * Describes additional debugging info. + * + * @generated from message google.rpc.DebugInfo + */ +export type DebugInfo = Message<"google.rpc.DebugInfo"> & { + /** + * The stack trace entries indicating where the error occurred. + * + * @generated from field: repeated string stack_entries = 1; + */ + stackEntries: string[]; + + /** + * Additional debugging information provided by the server. + * + * @generated from field: string detail = 2; + */ + detail: string; +}; + +/** + * Describes the message google.rpc.DebugInfo. + * Use `create(DebugInfoSchema)` to create a new message. + */ +export const DebugInfoSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_google_rpc_error_details, 2); + +/** + * Describes how a quota check failed. + * + * For example if a daily limit was exceeded for the calling project, + * a service could respond with a QuotaFailure detail containing the project + * id and the description of the quota limit that was exceeded. If the + * calling project hasn't enabled the service in the developer console, then + * a service could respond with the project id and set `service_disabled` + * to true. + * + * Also see RetryInfo and Help types for other details about handling a + * quota failure. + * + * @generated from message google.rpc.QuotaFailure + */ +export type QuotaFailure = Message<"google.rpc.QuotaFailure"> & { + /** + * Describes all quota violations. + * + * @generated from field: repeated google.rpc.QuotaFailure.Violation violations = 1; + */ + violations: QuotaFailure_Violation[]; +}; + +/** + * Describes the message google.rpc.QuotaFailure. + * Use `create(QuotaFailureSchema)` to create a new message. + */ +export const QuotaFailureSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_google_rpc_error_details, 3); + +/** + * A message type used to describe a single quota violation. For example, a + * daily quota or a custom quota that was exceeded. + * + * @generated from message google.rpc.QuotaFailure.Violation + */ +export type QuotaFailure_Violation = Message<"google.rpc.QuotaFailure.Violation"> & { + /** + * The subject on which the quota check failed. + * For example, "clientip:" or "project:". + * + * @generated from field: string subject = 1; + */ + subject: string; + + /** + * A description of how the quota check failed. Clients can use this + * description to find more about the quota configuration in the service's + * public documentation, or find the relevant quota limit to adjust through + * developer console. + * + * For example: "Service disabled" or "Daily Limit for read operations + * exceeded". + * + * @generated from field: string description = 2; + */ + description: string; + + /** + * The API Service from which the `QuotaFailure.Violation` orginates. In + * some cases, Quota issues originate from an API Service other than the one + * that was called. In other words, a dependency of the called API Service + * could be the cause of the `QuotaFailure`, and this field would have the + * dependency API service name. + * + * For example, if the called API is Kubernetes Engine API + * (container.googleapis.com), and a quota violation occurs in the + * Kubernetes Engine API itself, this field would be + * "container.googleapis.com". On the other hand, if the quota violation + * occurs when the Kubernetes Engine API creates VMs in the Compute Engine + * API (compute.googleapis.com), this field would be + * "compute.googleapis.com". + * + * @generated from field: string api_service = 3; + */ + apiService: string; + + /** + * The metric of the violated quota. A quota metric is a named counter to + * measure usage, such as API requests or CPUs. When an activity occurs in a + * service, such as Virtual Machine allocation, one or more quota metrics + * may be affected. + * + * For example, "compute.googleapis.com/cpus_per_vm_family", + * "storage.googleapis.com/internet_egress_bandwidth". + * + * @generated from field: string quota_metric = 4; + */ + quotaMetric: string; + + /** + * The id of the violated quota. Also know as "limit name", this is the + * unique identifier of a quota in the context of an API service. + * + * For example, "CPUS-PER-VM-FAMILY-per-project-region". + * + * @generated from field: string quota_id = 5; + */ + quotaId: string; + + /** + * The dimensions of the violated quota. Every non-global quota is enforced + * on a set of dimensions. While quota metric defines what to count, the + * dimensions specify for what aspects the counter should be increased. + * + * For example, the quota "CPUs per region per VM family" enforces a limit + * on the metric "compute.googleapis.com/cpus_per_vm_family" on dimensions + * "region" and "vm_family". And if the violation occurred in region + * "us-central1" and for VM family "n1", the quota_dimensions would be, + * + * { + * "region": "us-central1", + * "vm_family": "n1", + * } + * + * When a quota is enforced globally, the quota_dimensions would always be + * empty. + * + * @generated from field: map quota_dimensions = 6; + */ + quotaDimensions: { [key: string]: string }; + + /** + * The enforced quota value at the time of the `QuotaFailure`. + * + * For example, if the enforced quota value at the time of the + * `QuotaFailure` on the number of CPUs is "10", then the value of this + * field would reflect this quantity. + * + * @generated from field: int64 quota_value = 7; + */ + quotaValue: bigint; + + /** + * The new quota value being rolled out at the time of the violation. At the + * completion of the rollout, this value will be enforced in place of + * quota_value. If no rollout is in progress at the time of the violation, + * this field is not set. + * + * For example, if at the time of the violation a rollout is in progress + * changing the number of CPUs quota from 10 to 20, 20 would be the value of + * this field. + * + * @generated from field: optional int64 future_quota_value = 8; + */ + futureQuotaValue?: bigint | undefined; +}; + +/** + * Describes the message google.rpc.QuotaFailure.Violation. + * Use `create(QuotaFailure_ViolationSchema)` to create a new message. + */ +export const QuotaFailure_ViolationSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_google_rpc_error_details, 3, 0); + +/** + * Describes what preconditions have failed. + * + * For example, if an RPC failed because it required the Terms of Service to be + * acknowledged, it could list the terms of service violation in the + * PreconditionFailure message. + * + * @generated from message google.rpc.PreconditionFailure + */ +export type PreconditionFailure = Message<"google.rpc.PreconditionFailure"> & { + /** + * Describes all precondition violations. + * + * @generated from field: repeated google.rpc.PreconditionFailure.Violation violations = 1; + */ + violations: PreconditionFailure_Violation[]; +}; + +/** + * Describes the message google.rpc.PreconditionFailure. + * Use `create(PreconditionFailureSchema)` to create a new message. + */ +export const PreconditionFailureSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_google_rpc_error_details, 4); + +/** + * A message type used to describe a single precondition failure. + * + * @generated from message google.rpc.PreconditionFailure.Violation + */ +export type PreconditionFailure_Violation = Message<"google.rpc.PreconditionFailure.Violation"> & { + /** + * The type of PreconditionFailure. We recommend using a service-specific + * enum type to define the supported precondition violation subjects. For + * example, "TOS" for "Terms of Service violation". + * + * @generated from field: string type = 1; + */ + type: string; + + /** + * The subject, relative to the type, that failed. + * For example, "google.com/cloud" relative to the "TOS" type would indicate + * which terms of service is being referenced. + * + * @generated from field: string subject = 2; + */ + subject: string; + + /** + * A description of how the precondition failed. Developers can use this + * description to understand how to fix the failure. + * + * For example: "Terms of service not accepted". + * + * @generated from field: string description = 3; + */ + description: string; +}; + +/** + * Describes the message google.rpc.PreconditionFailure.Violation. + * Use `create(PreconditionFailure_ViolationSchema)` to create a new message. + */ +export const PreconditionFailure_ViolationSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_google_rpc_error_details, 4, 0); + +/** + * Describes violations in a client request. This error type focuses on the + * syntactic aspects of the request. + * + * @generated from message google.rpc.BadRequest + */ +export type BadRequest = Message<"google.rpc.BadRequest"> & { + /** + * Describes all violations in a client request. + * + * @generated from field: repeated google.rpc.BadRequest.FieldViolation field_violations = 1; + */ + fieldViolations: BadRequest_FieldViolation[]; +}; + +/** + * Describes the message google.rpc.BadRequest. + * Use `create(BadRequestSchema)` to create a new message. + */ +export const BadRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_google_rpc_error_details, 5); + +/** + * A message type used to describe a single bad request field. + * + * @generated from message google.rpc.BadRequest.FieldViolation + */ +export type BadRequest_FieldViolation = Message<"google.rpc.BadRequest.FieldViolation"> & { + /** + * A path that leads to a field in the request body. The value will be a + * sequence of dot-separated identifiers that identify a protocol buffer + * field. + * + * Consider the following: + * + * message CreateContactRequest { + * message EmailAddress { + * enum Type { + * TYPE_UNSPECIFIED = 0; + * HOME = 1; + * WORK = 2; + * } + * + * optional string email = 1; + * repeated EmailType type = 2; + * } + * + * string full_name = 1; + * repeated EmailAddress email_addresses = 2; + * } + * + * In this example, in proto `field` could take one of the following values: + * + * * `full_name` for a violation in the `full_name` value + * * `email_addresses[0].email` for a violation in the `email` field of the + * first `email_addresses` message + * * `email_addresses[2].type[1]` for a violation in the second `type` + * value in the third `email_addresses` message. + * + * In JSON, the same values are represented as: + * + * * `fullName` for a violation in the `fullName` value + * * `emailAddresses[0].email` for a violation in the `email` field of the + * first `emailAddresses` message + * * `emailAddresses[2].type[1]` for a violation in the second `type` + * value in the third `emailAddresses` message. + * + * @generated from field: string field = 1; + */ + field: string; + + /** + * A description of why the request element is bad. + * + * @generated from field: string description = 2; + */ + description: string; + + /** + * The reason of the field-level error. This is a constant value that + * identifies the proximate cause of the field-level error. It should + * uniquely identify the type of the FieldViolation within the scope of the + * google.rpc.ErrorInfo.domain. This should be at most 63 + * characters and match a regular expression of `[A-Z][A-Z0-9_]+[A-Z0-9]`, + * which represents UPPER_SNAKE_CASE. + * + * @generated from field: string reason = 3; + */ + reason: string; + + /** + * Provides a localized error message for field-level errors that is safe to + * return to the API consumer. + * + * @generated from field: google.rpc.LocalizedMessage localized_message = 4; + */ + localizedMessage?: LocalizedMessage | undefined; +}; + +/** + * Describes the message google.rpc.BadRequest.FieldViolation. + * Use `create(BadRequest_FieldViolationSchema)` to create a new message. + */ +export const BadRequest_FieldViolationSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_google_rpc_error_details, 5, 0); + +/** + * Contains metadata about the request that clients can attach when filing a bug + * or providing other forms of feedback. + * + * @generated from message google.rpc.RequestInfo + */ +export type RequestInfo = Message<"google.rpc.RequestInfo"> & { + /** + * An opaque string that should only be interpreted by the service generating + * it. For example, it can be used to identify requests in the service's logs. + * + * @generated from field: string request_id = 1; + */ + requestId: string; + + /** + * Any data that was used to serve this request. For example, an encrypted + * stack trace that can be sent back to the service provider for debugging. + * + * @generated from field: string serving_data = 2; + */ + servingData: string; +}; + +/** + * Describes the message google.rpc.RequestInfo. + * Use `create(RequestInfoSchema)` to create a new message. + */ +export const RequestInfoSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_google_rpc_error_details, 6); + +/** + * Describes the resource that is being accessed. + * + * @generated from message google.rpc.ResourceInfo + */ +export type ResourceInfo = Message<"google.rpc.ResourceInfo"> & { + /** + * A name for the type of resource being accessed, e.g. "sql table", + * "cloud storage bucket", "file", "Google calendar"; or the type URL + * of the resource: e.g. "type.googleapis.com/google.pubsub.v1.Topic". + * + * @generated from field: string resource_type = 1; + */ + resourceType: string; + + /** + * The name of the resource being accessed. For example, a shared calendar + * name: "example.com_4fghdhgsrgh@group.calendar.google.com", if the current + * error is + * [google.rpc.Code.PERMISSION_DENIED][google.rpc.Code.PERMISSION_DENIED]. + * + * @generated from field: string resource_name = 2; + */ + resourceName: string; + + /** + * The owner of the resource (optional). + * For example, "user:" or "project:". + * + * @generated from field: string owner = 3; + */ + owner: string; + + /** + * Describes what error is encountered when accessing this resource. + * For example, updating a cloud project may require the `writer` permission + * on the developer console project. + * + * @generated from field: string description = 4; + */ + description: string; +}; + +/** + * Describes the message google.rpc.ResourceInfo. + * Use `create(ResourceInfoSchema)` to create a new message. + */ +export const ResourceInfoSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_google_rpc_error_details, 7); + +/** + * Provides links to documentation or for performing an out of band action. + * + * For example, if a quota check failed with an error indicating the calling + * project hasn't enabled the accessed service, this can contain a URL pointing + * directly to the right place in the developer console to flip the bit. + * + * @generated from message google.rpc.Help + */ +export type Help = Message<"google.rpc.Help"> & { + /** + * URL(s) pointing to additional information on handling the current error. + * + * @generated from field: repeated google.rpc.Help.Link links = 1; + */ + links: Help_Link[]; +}; + +/** + * Describes the message google.rpc.Help. + * Use `create(HelpSchema)` to create a new message. + */ +export const HelpSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_google_rpc_error_details, 8); + +/** + * Describes a URL link. + * + * @generated from message google.rpc.Help.Link + */ +export type Help_Link = Message<"google.rpc.Help.Link"> & { + /** + * Describes what the link offers. + * + * @generated from field: string description = 1; + */ + description: string; + + /** + * The URL of the link. + * + * @generated from field: string url = 2; + */ + url: string; +}; + +/** + * Describes the message google.rpc.Help.Link. + * Use `create(Help_LinkSchema)` to create a new message. + */ +export const Help_LinkSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_google_rpc_error_details, 8, 0); + +/** + * Provides a localized error message that is safe to return to the user + * which can be attached to an RPC error. + * + * @generated from message google.rpc.LocalizedMessage + */ +export type LocalizedMessage = Message<"google.rpc.LocalizedMessage"> & { + /** + * The locale used following the specification defined at + * https://www.rfc-editor.org/rfc/bcp/bcp47.txt. + * Examples are: "en-US", "fr-CH", "es-MX" + * + * @generated from field: string locale = 1; + */ + locale: string; + + /** + * The localized error message in the above locale. + * + * @generated from field: string message = 2; + */ + message: string; +}; + +/** + * Describes the message google.rpc.LocalizedMessage. + * Use `create(LocalizedMessageSchema)` to create a new message. + */ +export const LocalizedMessageSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_google_rpc_error_details, 9); + diff --git a/src/gen/openshell_pb.ts b/src/gen/openshell_pb.ts new file mode 100644 index 0000000..659b416 --- /dev/null +++ b/src/gen/openshell_pb.ts @@ -0,0 +1,11926 @@ +// SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +// @generated by protoc-gen-es v2.12.1 with parameter "target=ts,import_extension=js" +// @generated from file openshell.proto (package openshell.v1, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv2"; +import { enumDesc, fileDesc, messageDesc, serviceDesc } from "@bufbuild/protobuf/codegenv2"; +import type { ObjectMeta, Provider, Workspace, WorkspaceSelector } from "./datamodel_pb.js"; +import { file_datamodel } from "./datamodel_pb.js"; +import type { Duration, Timestamp } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_duration, file_google_protobuf_struct, file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt"; +import { file_options } from "./options_pb.js"; +import type { GetGatewayConfigRequestSchema, GetGatewayConfigResponseSchema, GetSandboxConfigRequestSchema, GetSandboxConfigResponseSchema, L7DenyRule, L7Rule, NetworkBinary, NetworkEndpoint, NetworkPolicyRule, PolicySource, SandboxConfigSnapshot, SandboxPolicy, SandboxServiceRoute, SettingValue } from "./sandbox_pb.js"; +import { file_sandbox } from "./sandbox_pb.js"; +import type { JsonObject, Message } from "@bufbuild/protobuf"; + +/** + * Describes the file openshell.proto. + */ +export const file_openshell: GenFile = /*@__PURE__*/ + fileDesc("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", [file_datamodel, file_google_protobuf_duration, file_google_protobuf_struct, file_google_protobuf_timestamp, file_options, file_sandbox]); + +/** + * IssueSandboxToken request. Empty body; identity is established by the + * authentication credentials carried in the request headers (a projected + * Kubernetes ServiceAccount JWT in the K8s driver path). + * + * @generated from message openshell.v1.IssueSandboxTokenRequest + */ +export type IssueSandboxTokenRequest = Message<"openshell.v1.IssueSandboxTokenRequest"> & { +}; + +/** + * Describes the message openshell.v1.IssueSandboxTokenRequest. + * Use `create(IssueSandboxTokenRequestSchema)` to create a new message. + */ +export const IssueSandboxTokenRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 0); + +/** + * IssueSandboxToken response. The supervisor caches the returned token in + * memory and presents it as `Authorization: Bearer` on every subsequent + * gateway RPC. + * + * @generated from message openshell.v1.IssueSandboxTokenResponse + */ +export type IssueSandboxTokenResponse = Message<"openshell.v1.IssueSandboxTokenResponse"> & { + /** + * Gateway-minted session JWT bound to the calling sandbox's UUID, active + * runtime generation, authorization epoch, and durable token lineage. + * + * @generated from field: string token = 1; + */ + token: string; + + /** + * Absolute expiry of the issued token. Absence means the token is non-expiring. + * + * @generated from field: google.protobuf.Timestamp expiration_time = 102; + */ + expirationTime?: Timestamp | undefined; +}; + +/** + * Describes the message openshell.v1.IssueSandboxTokenResponse. + * Use `create(IssueSandboxTokenResponseSchema)` to create a new message. + */ +export const IssueSandboxTokenResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 1); + +/** + * RefreshSandboxToken request. The calling principal must already be a + * sandbox principal (i.e. the request carries a still-valid gateway-minted + * JWT in its Authorization header). Extension service names are resolved + * against server-owned registrations and the sandbox's effective policy; + * callers never choose token audiences directly. + * + * @generated from message openshell.v1.RefreshSandboxTokenRequest + */ +export type RefreshSandboxTokenRequest = Message<"openshell.v1.RefreshSandboxTokenRequest"> & { + /** + * Operator registration names for extension services selected by the + * sandbox's effective policy. + * + * @generated from field: repeated string extension_service_names = 1; + */ + extensionServiceNames: string[]; +}; + +/** + * Describes the message openshell.v1.RefreshSandboxTokenRequest. + * Use `create(RefreshSandboxTokenRequestSchema)` to create a new message. + */ +export const RefreshSandboxTokenRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 2); + +/** + * RefreshSandboxToken response. The new token replaces the supervisor's + * in-memory bearer credential. + * + * @generated from message openshell.v1.RefreshSandboxTokenResponse + */ +export type RefreshSandboxTokenResponse = Message<"openshell.v1.RefreshSandboxTokenResponse"> & { + /** + * Fresh gateway-minted JWT bound to the same sandbox UUID. + * + * @generated from field: string token = 1; + */ + token: string; + + /** + * Absolute expiry of the new token. Absence means the token is non-expiring. + * + * @generated from field: google.protobuf.Timestamp expiration_time = 102; + */ + expirationTime?: Timestamp | undefined; + + /** + * Fresh credentials for the requested, policy-authorized extension + * services. These remain in supervisor memory and are never persisted. + * + * @generated from field: repeated openshell.v1.ExtensionServiceCredential extension_credentials = 3; + */ + extensionCredentials: ExtensionServiceCredential[]; + + /** + * Fresh Sandbox Protocol bearer token from the same atomic refresh. + * + * @generated from field: string sandbox_token = 4; + */ + sandboxToken: string; + + /** + * Absolute Sandbox Protocol token expiry. Absence means the token is non-expiring. + * + * @generated from field: google.protobuf.Timestamp sandbox_expiration_time = 105; + */ + sandboxExpirationTime?: Timestamp | undefined; + + /** + * Launch generation to which both refreshed credentials are bound. + * + * @generated from field: string session_id = 6; + */ + sessionId: string; + + /** + * Durable authorization epoch shared by the gateway and Sandbox Runtime. + * + * @generated from field: uint64 credential_epoch = 7; + */ + credentialEpoch: bigint; +}; + +/** + * Describes the message openshell.v1.RefreshSandboxTokenResponse. + * Use `create(RefreshSandboxTokenResponseSchema)` to create a new message. + */ +export const RefreshSandboxTokenResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 3); + +/** + * Health check request. + * + * @generated from message openshell.v1.HealthRequest + */ +export type HealthRequest = Message<"openshell.v1.HealthRequest"> & { +}; + +/** + * Describes the message openshell.v1.HealthRequest. + * Use `create(HealthRequestSchema)` to create a new message. + */ +export const HealthRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 4); + +/** + * Health check response. + * + * @generated from message openshell.v1.HealthResponse + */ +export type HealthResponse = Message<"openshell.v1.HealthResponse"> & { + /** + * Service status. + * + * @generated from field: openshell.v1.ServiceStatus status = 1; + */ + status: ServiceStatus; + + /** + * Service version. + * + * @generated from field: string version = 2; + */ + version: string; +}; + +/** + * Describes the message openshell.v1.HealthResponse. + * Use `create(HealthResponseSchema)` to create a new message. + */ +export const HealthResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 5); + +/** + * Current-user request. The identity comes from the authenticated request. + * + * @generated from message openshell.v1.GetCurrentUserRequest + */ +export type GetCurrentUserRequest = Message<"openshell.v1.GetCurrentUserRequest"> & { +}; + +/** + * Describes the message openshell.v1.GetCurrentUserRequest. + * Use `create(GetCurrentUserRequestSchema)` to create a new message. + */ +export const GetCurrentUserRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 6); + +/** + * Authenticated user identity as validated by the gateway. + * + * @generated from message openshell.v1.GetCurrentUserResponse + */ +export type GetCurrentUserResponse = Message<"openshell.v1.GetCurrentUserResponse"> & { + /** + * Stable identity subject (for example, the OIDC `sub` claim). + * + * @generated from field: string subject = 1; + */ + subject: string; + + /** + * Human-readable identity name when supplied by the authentication provider. + * + * @generated from field: string display_name = 2; + */ + displayName: string; + + /** + * Roles granted to the authenticated identity. + * + * @generated from field: repeated string roles = 3; + */ + roles: string[]; + + /** + * OAuth2 scopes granted to the authenticated identity. + * + * @generated from field: repeated string scopes = 4; + */ + scopes: string[]; + + /** + * Authentication provider that established the identity. + * + * @generated from field: string identity_provider = 5; + */ + identityProvider: string; +}; + +/** + * Describes the message openshell.v1.GetCurrentUserResponse. + * Use `create(GetCurrentUserResponseSchema)` to create a new message. + */ +export const GetCurrentUserResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 7); + +/** + * Gateway info request. + * + * @generated from message openshell.v1.GetGatewayInfoRequest + */ +export type GetGatewayInfoRequest = Message<"openshell.v1.GetGatewayInfoRequest"> & { +}; + +/** + * Describes the message openshell.v1.GetGatewayInfoRequest. + * Use `create(GetGatewayInfoRequestSchema)` to create a new message. + */ +export const GetGatewayInfoRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 8); + +/** + * Gateway info response. + * + * @generated from message openshell.v1.GetGatewayInfoResponse + */ +export type GetGatewayInfoResponse = Message<"openshell.v1.GetGatewayInfoResponse"> & { + /** + * Service status. + * + * @generated from field: openshell.v1.ServiceStatus status = 1; + */ + status: ServiceStatus; + + /** + * OpenShell gateway binary version. + * + * @generated from field: string gateway_version = 2; + */ + gatewayVersion: string; + + /** + * Compute driver runtimes initialized by this gateway. Current gateways + * return exactly one entry. + * + * @generated from field: repeated openshell.v1.ComputeDriverInfo compute_drivers = 3; + */ + computeDrivers: ComputeDriverInfo[]; + + /** + * Negotiated non-secret metadata for every initialized extension. + * + * @generated from field: repeated openshell.v1.NegotiatedExtensionInfo extensions = 4; + */ + extensions: NegotiatedExtensionInfo[]; +}; + +/** + * Describes the message openshell.v1.GetGatewayInfoResponse. + * Use `create(GetGatewayInfoResponseSchema)` to create a new message. + */ +export const GetGatewayInfoResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 9); + +/** + * Public, non-secret snapshot of one successful startup negotiation. + * + * @generated from message openshell.v1.NegotiatedExtensionInfo + */ +export type NegotiatedExtensionInfo = Message<"openshell.v1.NegotiatedExtensionInfo"> & { + /** + * @generated from field: openshell.v1.ExtensionKind kind = 1; + */ + kind: ExtensionKind; + + /** + * Gateway/operator-selected registration name. + * + * @generated from field: string configured_name = 2; + */ + configuredName: string; + + /** + * Extension-reported implementation identity. + * + * @generated from field: string implementation_name = 3; + */ + implementationName: string; + + /** + * Extension build version, distinct from the protocol version. + * + * @generated from field: string implementation_version = 4; + */ + implementationVersion: string; + + /** + * @generated from field: uint32 protocol_major = 5; + */ + protocolMajor: number; + + /** + * @generated from field: uint32 protocol_minor = 6; + */ + protocolMinor: number; + + /** + * Extension-supported optional capabilities, sorted for stable output. + * + * @generated from field: repeated string supported_capabilities = 7; + */ + supportedCapabilities: string[]; + + /** + * Capabilities the extension requires from the gateway. + * + * @generated from field: repeated string required_capabilities = 8; + */ + requiredCapabilities: string[]; +}; + +/** + * Describes the message openshell.v1.NegotiatedExtensionInfo. + * Use `create(NegotiatedExtensionInfoSchema)` to create a new message. + */ +export const NegotiatedExtensionInfoSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 10); + +/** + * Info for one initialized compute driver runtime. + * + * @generated from message openshell.v1.ComputeDriverInfo + */ +export type ComputeDriverInfo = Message<"openshell.v1.ComputeDriverInfo"> & { + /** + * Gateway-selected driver name used for routing and driver_config keys. + * + * @generated from field: string name = 1; + */ + name: string; + + /** + * Capabilities reported by the driver during gateway runtime initialization. + * + * @generated from field: openshell.v1.ComputeDriverCapabilities capabilities = 2; + */ + capabilities?: ComputeDriverCapabilities | undefined; +}; + +/** + * Describes the message openshell.v1.ComputeDriverInfo. + * Use `create(ComputeDriverInfoSchema)` to create a new message. + */ +export const ComputeDriverInfoSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 11); + +/** + * Public compute driver capability snapshot. + * + * @generated from message openshell.v1.ComputeDriverCapabilities + */ +export type ComputeDriverCapabilities = Message<"openshell.v1.ComputeDriverCapabilities"> & { + /** + * Driver-reported human-readable name from the startup capability snapshot. + * + * @generated from field: string driver_name = 1; + */ + driverName: string; + + /** + * Driver-reported implementation version from the startup capability snapshot. + * + * @generated from field: string driver_version = 2; + */ + driverVersion: string; + + /** + * Static portable resource request forms reported by the driver. + * + * @generated from field: openshell.v1.ResourceCapabilities resource_capabilities = 3; + */ + resourceCapabilities?: ResourceCapabilities | undefined; +}; + +/** + * Describes the message openshell.v1.ComputeDriverCapabilities. + * Use `create(ComputeDriverCapabilitiesSchema)` to create a new message. + */ +export const ComputeDriverCapabilitiesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 12); + +/** + * Static portable resource request forms reported by a compute driver. + * An omitted domain means the driver does not report that domain. + * + * @generated from message openshell.v1.ResourceCapabilities + */ +export type ResourceCapabilities = Message<"openshell.v1.ResourceCapabilities"> & { + /** + * @generated from field: openshell.v1.CpuResourceCapabilities cpu = 1; + */ + cpu?: CpuResourceCapabilities | undefined; + + /** + * @generated from field: openshell.v1.MemoryResourceCapabilities memory = 2; + */ + memory?: MemoryResourceCapabilities | undefined; + + /** + * @generated from field: openshell.v1.GpuResourceCapabilities gpu = 3; + */ + gpu?: GpuResourceCapabilities | undefined; +}; + +/** + * Describes the message openshell.v1.ResourceCapabilities. + * Use `create(ResourceCapabilitiesSchema)` to create a new message. + */ +export const ResourceCapabilitiesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 13); + +/** + * @generated from message openshell.v1.CpuResourceCapabilities + */ +export type CpuResourceCapabilities = Message<"openshell.v1.CpuResourceCapabilities"> & { + /** + * The driver accepts and enforces a portable CPU limit. + * + * @generated from field: bool limit_supported = 1; + */ + limitSupported: boolean; +}; + +/** + * Describes the message openshell.v1.CpuResourceCapabilities. + * Use `create(CpuResourceCapabilitiesSchema)` to create a new message. + */ +export const CpuResourceCapabilitiesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 14); + +/** + * @generated from message openshell.v1.MemoryResourceCapabilities + */ +export type MemoryResourceCapabilities = Message<"openshell.v1.MemoryResourceCapabilities"> & { + /** + * The driver accepts and enforces a portable memory limit. + * + * @generated from field: bool limit_supported = 1; + */ + limitSupported: boolean; +}; + +/** + * Describes the message openshell.v1.MemoryResourceCapabilities. + * Use `create(MemoryResourceCapabilitiesSchema)` to create a new message. + */ +export const MemoryResourceCapabilitiesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 15); + +/** + * @generated from message openshell.v1.GpuResourceCapabilities + */ +export type GpuResourceCapabilities = Message<"openshell.v1.GpuResourceCapabilities"> & { + /** + * The driver accepts a GPU request with no explicit count. + * + * @generated from field: bool default_selection_supported = 1; + */ + defaultSelectionSupported: boolean; + + /** + * The driver accepts an explicit `gpu.count` request. + * + * @generated from field: bool count_selection_supported = 2; + */ + countSelectionSupported: boolean; +}; + +/** + * Describes the message openshell.v1.GpuResourceCapabilities. + * Use `create(GpuResourceCapabilitiesSchema)` to create a new message. + */ +export const GpuResourceCapabilitiesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 16); + +/** + * Public sandbox resource exposed by the OpenShell API. + * + * This is the canonical gateway-owned view of a sandbox. It merges user intent + * (`spec`) with gateway-managed metadata and status derived from internal + * compute-driver observations. + * + * Note: The `namespace` field has been removed from the public API. It remains + * in the internal `DriverSandbox` message as a compute-driver implementation detail. + * + * @generated from message openshell.v1.Sandbox + */ +export type Sandbox = Message<"openshell.v1.Sandbox"> & { + /** + * Kubernetes-style metadata (id, name, labels, timestamps, resource version). + * + * @generated from field: openshell.datamodel.v1.ObjectMeta metadata = 1; + */ + metadata?: ObjectMeta | undefined; + + /** + * Desired sandbox configuration submitted through the API. + * + * @generated from field: openshell.v1.SandboxSpec spec = 2; + */ + spec?: SandboxSpec | undefined; + + /** + * Latest user-facing observed status derived by the gateway. + * + * @generated from field: openshell.v1.SandboxStatus status = 3; + */ + status?: SandboxStatus | undefined; + + /** + * Read-only SSH host identity in OpenSSH SHA256: form. Stable for + * this sandbox's lifetime, including runtime restarts. Empty on legacy + * runtimes that do not provide a gateway-managed SSH identity. + * + * @generated from field: string host_key_fingerprint = 6; + */ + hostKeyFingerprint: string; + + /** + * Read-only provenance for sandboxes created from a reusable workload template. + * + * @generated from field: openshell.v1.SandboxWorkloadTemplateProvenance created_from_workload_template = 20; + */ + createdFromWorkloadTemplate?: SandboxWorkloadTemplateProvenance | undefined; +}; + +/** + * Describes the message openshell.v1.Sandbox. + * Use `create(SandboxSchema)` to create a new message. + */ +export const SandboxSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 17); + +/** + * Desired sandbox configuration provided through the public API. + * + * @generated from message openshell.v1.SandboxSpec + */ +export type SandboxSpec = Message<"openshell.v1.SandboxSpec"> & { + /** + * Log level exposed to processes running inside the sandbox. + * + * @generated from field: string log_level = 1; + */ + logLevel: string; + + /** + * Environment variables injected into the sandbox runtime. + * + * @generated from field: map environment = 5; + */ + environment: { [key: string]: string }; + + /** + * Container or VM template used to provision the sandbox. + * + * @generated from field: openshell.v1.SandboxTemplate template = 6; + */ + template?: SandboxTemplate | undefined; + + /** + * Required sandbox policy configuration. + * + * @generated from field: openshell.sandbox.v1.SandboxPolicy policy = 7; + */ + policy?: SandboxPolicy | undefined; + + /** + * Provider names to attach to this sandbox. + * + * @generated from field: repeated string providers = 8; + */ + providers: string[]; + + /** + * Portable resource requirements used by the gateway for driver selection + * and by drivers for provisioning. + * + * @generated from field: openshell.v1.ResourceRequirements resource_requirements = 9; + */ + resourceRequirements?: ResourceRequirements | undefined; + + /** + * 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. + * + * @generated from field: repeated string command = 12; + */ + command: string[]; + + /** + * Allocate a retained pseudo-terminal for the main process. + * + * @generated from field: bool tty = 13; + */ + tty: boolean; + + /** + * Gateway-owned attachment identity, changed atomically with the provider set. + * Equality only: detach and reattach must not revive an older receipt. + * + * @generated from field: string provider_attachment_epoch = 14; + */ + providerAttachmentEpoch: string; + + /** + * Gateway-owned policy for replacing the sandbox runtime after the canonical + * main process exits. Unspecified is normalized to Never before persistence. + * + * @generated from field: openshell.v1.SandboxRestartPolicy restart_policy = 15; + */ + restartPolicy: SandboxRestartPolicy; +}; + +/** + * Describes the message openshell.v1.SandboxSpec. + * Use `create(SandboxSpecSchema)` to create a new message. + */ +export const SandboxSpecSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 18); + +/** + * @generated from message openshell.v1.ResourceRequirements + */ +export type ResourceRequirements = Message<"openshell.v1.ResourceRequirements"> & { + /** + * GPU requirements for the sandbox. Presence indicates a GPU request. + * + * @generated from field: openshell.v1.GpuResourceRequirements gpu = 1; + */ + gpu?: GpuResourceRequirements | undefined; +}; + +/** + * Describes the message openshell.v1.ResourceRequirements. + * Use `create(ResourceRequirementsSchema)` to create a new message. + */ +export const ResourceRequirementsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 19); + +/** + * Public GPU resource requirements. + * + * @generated from message openshell.v1.GpuResourceRequirements + */ +export type GpuResourceRequirements = Message<"openshell.v1.GpuResourceRequirements"> & { + /** + * Optional number of GPUs requested. When omitted, the request is for one + * GPU using the selected driver's default assignment behavior. + * + * @generated from field: optional uint32 count = 1; + */ + count?: number | undefined; +}; + +/** + * Describes the message openshell.v1.GpuResourceRequirements. + * Use `create(GpuResourceRequirementsSchema)` to create a new message. + */ +export const GpuResourceRequirementsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 20); + +/** + * Historical inline compute template mapped onto compute-driver template inputs. + * + * Despite its name, this is not a reusable named sandbox template resource. It + * is an inline part of `SandboxSpec` kept for v1 compatibility. A future + * breaking API cleanup may rename this message to free `SandboxTemplate` for + * the reusable template resource now represented by `SandboxWorkloadTemplate`. + * + * @generated from message openshell.v1.SandboxTemplate + */ +export type SandboxTemplate = Message<"openshell.v1.SandboxTemplate"> & { + /** + * Fully-qualified OCI image reference used to boot the sandbox. + * + * @generated from field: string image = 1; + */ + image: string; + + /** + * Optional runtime class name requested from the compute platform. + * + * @generated from field: string runtime_class_name = 2; + */ + runtimeClassName: string; + + /** + * Optional agent socket path exposed to the workload. + * + * @generated from field: string agent_socket = 3; + */ + agentSocket: string; + + /** + * Labels applied to compute-platform resources for this sandbox. + * + * @generated from field: map labels = 4; + */ + labels: { [key: string]: string }; + + /** + * Annotations applied to compute-platform resources for this sandbox. + * + * @generated from field: map annotations = 5; + */ + annotations: { [key: string]: string }; + + /** + * Additional environment variables injected by the template. + * + * @generated from field: map environment = 6; + */ + environment: { [key: string]: string }; + + /** + * Platform-specific compute resource requirements and limits. + * + * @generated from field: google.protobuf.Struct resources = 7; + */ + resources?: JsonObject | undefined; + + /** + * Enable Kubernetes user namespace isolation (hostUsers: false). + * When true, container UID 0 maps to a non-root host UID and capabilities + * become namespaced. Requires Kubernetes 1.33+ with user namespace support + * available (beta through 1.35, GA in 1.36+) and a supporting runtime. + * When unset, the cluster-wide default is used. + * + * @generated from field: optional bool user_namespaces = 10; + */ + userNamespaces?: boolean | undefined; + + /** + * Driver-keyed opaque config envelope supplied by the caller. + * The gateway selects the block matching the active compute driver and + * forwards only that inner Struct to DriverSandboxTemplate.driver_config. + * The selected driver owns nested schema validation. + * + * @generated from field: google.protobuf.Struct driver_config = 11; + */ + driverConfig?: JsonObject | undefined; +}; + +/** + * Describes the message openshell.v1.SandboxTemplate. + * Use `create(SandboxTemplateSchema)` to create a new message. + */ +export const SandboxTemplateSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 21); + +/** + * Reusable named sandbox workload template resource. + * + * This is the actual workspace-scoped template resource used to create + * sandboxes by reference. It uses the longer name in v1 to avoid colliding with + * the historical inline `SandboxTemplate` message. A future breaking API + * cleanup may rename this resource to `SandboxTemplate`. + * + * @generated from message openshell.v1.SandboxWorkloadTemplate + */ +export type SandboxWorkloadTemplate = Message<"openshell.v1.SandboxWorkloadTemplate"> & { + /** + * Kubernetes-style metadata (id, name, labels, timestamps, resource version). + * + * @generated from field: openshell.datamodel.v1.ObjectMeta metadata = 1; + */ + metadata?: ObjectMeta | undefined; + + /** + * Desired reusable workload shape and template-owned driver config. + * + * @generated from field: openshell.v1.SandboxWorkloadTemplateSpec spec = 2; + */ + spec?: SandboxWorkloadTemplateSpec | undefined; +}; + +/** + * Describes the message openshell.v1.SandboxWorkloadTemplate. + * Use `create(SandboxWorkloadTemplateSchema)` to create a new message. + */ +export const SandboxWorkloadTemplateSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 22); + +/** + * @generated from message openshell.v1.SandboxWorkloadTemplateSpec + */ +export type SandboxWorkloadTemplateSpec = Message<"openshell.v1.SandboxWorkloadTemplateSpec"> & { + /** + * Portable workload shape. + * + * @generated from field: openshell.v1.SandboxWorkloadConfig workload = 1; + */ + workload?: SandboxWorkloadConfig | undefined; + + /** + * Driver-keyed opaque config envelope supplied by the template owner. + * + * @generated from field: google.protobuf.Struct driver_config = 2; + */ + driverConfig?: JsonObject | undefined; + + /** + * Desired service level associated with this template. + * + * @generated from field: openshell.v1.SandboxServiceLevel desired_service_level = 3; + */ + desiredServiceLevel?: SandboxServiceLevel | undefined; +}; + +/** + * Describes the message openshell.v1.SandboxWorkloadTemplateSpec. + * Use `create(SandboxWorkloadTemplateSpecSchema)` to create a new message. + */ +export const SandboxWorkloadTemplateSpecSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 23); + +/** + * @generated from message openshell.v1.SandboxWorkloadConfig + */ +export type SandboxWorkloadConfig = Message<"openshell.v1.SandboxWorkloadConfig"> & { + /** + * Fully-qualified OCI image reference used to boot the sandbox. + * + * @generated from field: string image = 1; + */ + image: string; + + /** + * Environment variables injected into the sandbox runtime. + * + * @generated from field: map environment = 2; + */ + environment: { [key: string]: string }; + + /** + * Portable resource requirements for sandboxes created from this workload. + * + * @generated from field: openshell.v1.SandboxResources resources = 3; + */ + resources?: SandboxResources | undefined; +}; + +/** + * Describes the message openshell.v1.SandboxWorkloadConfig. + * Use `create(SandboxWorkloadConfigSchema)` to create a new message. + */ +export const SandboxWorkloadConfigSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 24); + +/** + * @generated from message openshell.v1.SandboxResources + */ +export type SandboxResources = Message<"openshell.v1.SandboxResources"> & { + /** + * Portable CPU quantity, for example "500m" or "2". + * + * @generated from field: string cpu = 1; + */ + cpu: string; + + /** + * Portable memory quantity, for example "512Mi" or "2Gi". + * + * @generated from field: string memory = 2; + */ + memory: string; + + /** + * GPU requirements for the sandbox workload. Presence indicates a GPU + * request. When count is omitted, the request uses the selected driver's + * default GPU assignment behavior. + * + * @generated from field: openshell.v1.GpuResourceRequirements gpu = 3; + */ + gpu?: GpuResourceRequirements | undefined; +}; + +/** + * Describes the message openshell.v1.SandboxResources. + * Use `create(SandboxResourcesSchema)` to create a new message. + */ +export const SandboxResourcesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 25); + +/** + * @generated from message openshell.v1.SandboxServiceLevel + */ +export type SandboxServiceLevel = Message<"openshell.v1.SandboxServiceLevel"> & { + /** + * @generated from field: openshell.v1.SandboxStartup startup = 1; + */ + startup?: SandboxStartup | undefined; +}; + +/** + * Describes the message openshell.v1.SandboxServiceLevel. + * Use `create(SandboxServiceLevelSchema)` to create a new message. + */ +export const SandboxServiceLevelSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 26); + +/** + * @generated from message openshell.v1.SandboxStartup + */ +export type SandboxStartup = Message<"openshell.v1.SandboxStartup"> & { + /** + * @generated from field: google.protobuf.Duration ready_within = 1; + */ + readyWithin?: Duration | undefined; + + /** + * @generated from field: uint32 max_burst = 2; + */ + maxBurst: number; +}; + +/** + * Describes the message openshell.v1.SandboxStartup. + * Use `create(SandboxStartupSchema)` to create a new message. + */ +export const SandboxStartupSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 27); + +/** + * @generated from message openshell.v1.SandboxWorkloadTemplateProvenance + */ +export type SandboxWorkloadTemplateProvenance = Message<"openshell.v1.SandboxWorkloadTemplateProvenance"> & { + /** + * @generated from field: string name = 1; + */ + name: string; + + /** + * @generated from field: string resource_version = 2; + */ + resourceVersion: string; +}; + +/** + * Describes the message openshell.v1.SandboxWorkloadTemplateProvenance. + * Use `create(SandboxWorkloadTemplateProvenanceSchema)` to create a new message. + */ +export const SandboxWorkloadTemplateProvenanceSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 28); + +/** + * User-facing sandbox status derived by the gateway from compute-driver observations. + * + * Public status does not embed driver-only flags such as `deleting`. + * + * @generated from message openshell.v1.SandboxStatus + */ +export type SandboxStatus = Message<"openshell.v1.SandboxStatus"> & { + /** + * Name of the agent pod or equivalent runtime instance. + * + * @generated from field: string agent_pod = 2; + */ + agentPod: string; + + /** + * File descriptor or endpoint for reaching the agent service, when available. + * + * @generated from field: string agent_fd = 3; + */ + agentFd: string; + + /** + * File descriptor or endpoint for reaching the sandbox service, when available. + * + * @generated from field: string sandbox_fd = 4; + */ + sandboxFd: string; + + /** + * Latest user-facing readiness and lifecycle conditions. + * + * @generated from field: repeated openshell.v1.SandboxCondition conditions = 5; + */ + conditions: SandboxCondition[]; + + /** + * Gateway-derived lifecycle summary. + * + * @generated from field: openshell.v1.SandboxPhase phase = 6; + */ + phase: SandboxPhase; + + /** + * Currently active policy version (updated when sandbox reports loaded). + * + * @generated from field: uint32 current_policy_version = 7; + */ + currentPolicyVersion: number; + + /** + * Supervisor instance currently associated with the canonical main process. + * The gateway uses this to reject stale exit reports after a restart. + * + * @generated from field: string main_process_instance_id = 8; + */ + mainProcessInstanceId: string; + + /** + * Most recent normalized main process result. Signal exits use 128 + signal number. + * Cleared when a replacement main process becomes ready. + * + * @generated from field: optional int32 exit_code = 9; + */ + exitCode?: number | undefined; + + /** + * Last accepted network result for each configured tool server endpoint. + * Currently populated for MCP-over-HTTP endpoints. These passive results + * remain separate from sandbox lifecycle conditions and readiness. + * + * @generated from field: repeated openshell.v1.EndpointStatus endpoint_statuses = 10; + */ + endpointStatuses: EndpointStatus[]; + + /** + * Independent of infrastructure phase; retained across driver observations. + * + * @generated from field: openshell.v1.SandboxConfigurationAdmission configuration_admission = 11; + */ + configurationAdmission?: SandboxConfigurationAdmission | undefined; + + /** + * Durable first-acceptance marker. Absent on legacy records; never reset by restart. + * + * @generated from field: optional bool configuration_activated = 12; + */ + configurationActivated?: boolean | undefined; + + /** + * Gateway-owned provisioning deadlines, retained after timeout for inspection and retry. + * + * @generated from field: openshell.v1.SandboxProvisioning provisioning = 13; + */ + provisioning?: SandboxProvisioning | undefined; + + /** + * Consecutive policy-driven restart number in the current crash loop. + * + * @generated from field: uint32 restart_count = 14; + */ + restartCount: number; + + /** + * Deadline for the next restart attempt or recovery check. + * + * @generated from field: google.protobuf.Timestamp next_restart_time = 15; + */ + nextRestartTime?: Timestamp | undefined; + + /** + * Time when the current main process became ready. + * + * @generated from field: google.protobuf.Timestamp main_process_started_time = 16; + */ + mainProcessStartedTime?: Timestamp | undefined; + + /** + * Latest refused token grant across all outbound HTTP protocols, including + * failures before a configured endpoint or credential could be selected. + * Matching grant success or a policy, provider, or supervisor reset clears it. + * + * @generated from field: openshell.v1.TokenGrantFailureObservation last_token_grant_failure = 17; + */ + lastTokenGrantFailure?: TokenGrantFailureObservation | undefined; +}; + +/** + * Describes the message openshell.v1.SandboxStatus. + * Use `create(SandboxStatusSchema)` to create a new message. + */ +export const SandboxStatusSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 29); + +/** + * User-facing sandbox condition derived from platform or gateway observations. + * + * @generated from message openshell.v1.SandboxCondition + */ +export type SandboxCondition = Message<"openshell.v1.SandboxCondition"> & { + /** + * Condition class, typically mirroring the underlying platform condition type. + * + * @generated from field: string type = 1; + */ + type: string; + + /** + * Condition status value such as `True`, `False`, or `Unknown`. + * + * @generated from field: string status = 2; + */ + status: string; + + /** + * Short machine-readable reason associated with the condition. + * + * @generated from field: string reason = 3; + */ + reason: string; + + /** + * Human-readable condition message. + * + * @generated from field: string message = 4; + */ + message: string; + + /** + * Timestamp reported by the condition owner for the last transition. + * + * @generated from field: google.protobuf.Timestamp transition_time = 105; + */ + transitionTime?: Timestamp | undefined; +}; + +/** + * Describes the message openshell.v1.SandboxCondition. + * Use `create(SandboxConditionSchema)` to create a new message. + */ +export const SandboxConditionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 30); + +/** + * Public platform event exposed on the sandbox watch stream. + * + * @generated from message openshell.v1.PlatformEvent + */ +export type PlatformEvent = Message<"openshell.v1.PlatformEvent"> & { + /** + * Time when the event occurred. + * + * @generated from field: google.protobuf.Timestamp event_time = 101; + */ + eventTime?: Timestamp | undefined; + + /** + * Event source (e.g. "kubernetes", "docker", "process"). + * + * @generated from field: string source = 2; + */ + source: string; + + /** + * Event type/severity (e.g. "Normal", "Warning"). + * + * @generated from field: string type = 3; + */ + type: string; + + /** + * Short reason code (e.g. "Started", "Pulled", "Failed"). + * + * @generated from field: string reason = 4; + */ + reason: string; + + /** + * Human-readable event message. + * + * @generated from field: string message = 5; + */ + message: string; + + /** + * Optional metadata as key-value pairs. + * + * @generated from field: map metadata = 6; + */ + metadata: { [key: string]: string }; +}; + +/** + * Describes the message openshell.v1.PlatformEvent. + * Use `create(PlatformEventSchema)` to create a new message. + */ +export const PlatformEventSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 31); + +/** + * Create sandbox request. + * + * @generated from message openshell.v1.CreateSandboxRequest + */ +export type CreateSandboxRequest = Message<"openshell.v1.CreateSandboxRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 7; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: openshell.v1.SandboxSpec spec = 1; + */ + spec?: SandboxSpec | undefined; + + /** + * Optional user-supplied sandbox name. When empty the server generates one. + * + * @generated from field: string name = 2; + */ + name: string; + + /** + * Optional labels for the sandbox (key-value metadata). + * + * @generated from field: map labels = 3; + */ + labels: { [key: string]: string }; + + /** + * Optional annotations for the sandbox (non-selector metadata). Keys under + * the `internal.openshell.ai/` prefix are reserved for the gateway. + * + * @generated from field: map annotations = 4; + */ + annotations: { [key: string]: string }; + + /** + * One-shot launch hint indicating that the creating client will attach to + * the canonical main process. The supervisor keeps the terminal transport + * alive until that attachment connects and closes naturally. + * + * @generated from field: bool await_main_process_attachment = 5; + */ + awaitMainProcessAttachment: boolean; + + /** + * Workspace-scoped SandboxWorkloadTemplate name to resolve at creation time. + * + * @generated from field: string workload_template = 6; + */ + workloadTemplate: string; + + /** + * Optional nonzero UUID for durable at-most-once admission. Successful results + * can be replayed for 24 hours; see the API errors and retries reference. + * + * @generated from field: string request_id = 8; + */ + requestId: string; + + /** + * HTTP services to expose when the sandbox is created. Endpoints are + * registered after the sandbox has been persisted and route only while the + * sandbox is ready. + * + * @generated from field: repeated openshell.v1.SandboxServiceExposure service_exposures = 9; + */ + serviceExposures: SandboxServiceExposure[]; +}; + +/** + * Describes the message openshell.v1.CreateSandboxRequest. + * Use `create(CreateSandboxRequestSchema)` to create a new message. + */ +export const CreateSandboxRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 32); + +/** + * Update selected configuration of a stopped sandbox. Omitted fields are unchanged. + * Start explicitly after a successful update. With no fields selected, resume + * the pending operation stored by the gateway using the current resource version. + * + * @generated from message openshell.v1.UpdateSandboxRequest + */ +export type UpdateSandboxRequest = Message<"openshell.v1.UpdateSandboxRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 1; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * Canonical name of the existing sandbox; this is not a rename or upsert. + * + * @generated from field: string name = 2; + */ + name: string; + + /** + * Nonempty OCI workload image reference. This does not change trusted runtime + * images or reseed an existing workspace. + * + * @generated from field: optional string image = 3; + */ + image?: string | undefined; + + /** + * Replace workload argv; an empty list restores image-resolved default shell behavior. + * + * @generated from field: openshell.v1.SandboxCommandUpdate command = 6; + */ + command?: SandboxCommandUpdate | undefined; + + /** + * Replace sandbox-level overrides. Empty clears overrides; template defaults remain. + * + * @generated from field: openshell.v1.SandboxMapUpdate environment = 7; + */ + environment?: SandboxMapUpdate | undefined; + + /** + * Replace user metadata, preserving gateway-owned keys. These do not set pod metadata. + * + * @generated from field: openshell.v1.SandboxMapUpdate labels = 8; + */ + labels?: SandboxMapUpdate | undefined; + + /** + * @generated from field: openshell.v1.SandboxMapUpdate annotations = 9; + */ + annotations?: SandboxMapUpdate | undefined; + + /** + * Required nonzero resource version read by the caller. + * + * @generated from field: uint64 expected_resource_version = 4; + */ + expectedResourceVersion: bigint; + + /** + * Optional nonzero UUID for durable at-most-once admission. + * + * @generated from field: string request_id = 5; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.UpdateSandboxRequest. + * Use `create(UpdateSandboxRequestSchema)` to create a new message. + */ +export const UpdateSandboxRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 33); + +/** + * Presence selects replacement, including an explicitly empty list. + * + * @generated from message openshell.v1.SandboxCommandUpdate + */ +export type SandboxCommandUpdate = Message<"openshell.v1.SandboxCommandUpdate"> & { + /** + * @generated from field: repeated string argv = 1; + */ + argv: string[]; +}; + +/** + * Describes the message openshell.v1.SandboxCommandUpdate. + * Use `create(SandboxCommandUpdateSchema)` to create a new message. + */ +export const SandboxCommandUpdateSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 34); + +/** + * Presence selects replacement, including an explicitly empty map. + * + * @generated from message openshell.v1.SandboxMapUpdate + */ +export type SandboxMapUpdate = Message<"openshell.v1.SandboxMapUpdate"> & { + /** + * @generated from field: map values = 1; + */ + values: { [key: string]: string }; +}; + +/** + * Describes the message openshell.v1.SandboxMapUpdate. + * Use `create(SandboxMapUpdateSchema)` to create a new message. + */ +export const SandboxMapUpdateSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 35); + +/** + * @generated from message openshell.v1.CreateSandboxTemplateRequest + */ +export type CreateSandboxTemplateRequest = Message<"openshell.v1.CreateSandboxTemplateRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 2; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: openshell.v1.SandboxWorkloadTemplate template = 1; + */ + template?: SandboxWorkloadTemplate | undefined; + + /** + * Optional nonzero UUID for durable at-most-once admission. Successful results + * can be replayed for 24 hours; see the API errors and retries reference. + * + * @generated from field: string request_id = 3; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.CreateSandboxTemplateRequest. + * Use `create(CreateSandboxTemplateRequestSchema)` to create a new message. + */ +export const CreateSandboxTemplateRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 36); + +/** + * @generated from message openshell.v1.GetSandboxTemplateRequest + */ +export type GetSandboxTemplateRequest = Message<"openshell.v1.GetSandboxTemplateRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 2; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: string name = 1; + */ + name: string; +}; + +/** + * Describes the message openshell.v1.GetSandboxTemplateRequest. + * Use `create(GetSandboxTemplateRequestSchema)` to create a new message. + */ +export const GetSandboxTemplateRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 37); + +/** + * @generated from message openshell.v1.ListSandboxTemplatesRequest + */ +export type ListSandboxTemplatesRequest = Message<"openshell.v1.ListSandboxTemplatesRequest"> & { + /** + * Workspace scope. Named and all-workspaces selections are accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 4; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * The maximum number of templates to return. Zero uses 100. Values above + * 1000 are coerced to 1000; negative values are invalid. + * + * @generated from field: int32 page_size = 1; + */ + pageSize: number; + + /** + * Token from a previous ListSandboxTemplates response. All other request + * parameters except page_size must match the request that produced it. + * + * @generated from field: string page_token = 2; + */ + pageToken: string; + + /** + * Optional label selector in key=value comma-separated form. + * + * @generated from field: string label_selector = 3; + */ + labelSelector: string; +}; + +/** + * Describes the message openshell.v1.ListSandboxTemplatesRequest. + * Use `create(ListSandboxTemplatesRequestSchema)` to create a new message. + */ +export const ListSandboxTemplatesRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 38); + +/** + * @generated from message openshell.v1.DeleteSandboxTemplateRequest + */ +export type DeleteSandboxTemplateRequest = Message<"openshell.v1.DeleteSandboxTemplateRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 2; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: string name = 1; + */ + name: string; + + /** + * Succeed with ALREADY_ABSENT if the target is missing. Authorization and + * parent-workspace checks still apply. + * + * @generated from field: bool allow_missing = 3; + */ + allowMissing: boolean; + + /** + * Optional nonzero UUID. Same ID and payload replay success for 24 hours. + * + * @generated from field: string request_id = 4; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.DeleteSandboxTemplateRequest. + * Use `create(DeleteSandboxTemplateRequestSchema)` to create a new message. + */ +export const DeleteSandboxTemplateRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 39); + +/** + * @generated from message openshell.v1.SandboxTemplateResponse + */ +export type SandboxTemplateResponse = Message<"openshell.v1.SandboxTemplateResponse"> & { + /** + * @generated from field: openshell.v1.SandboxWorkloadTemplate template = 1; + */ + template?: SandboxWorkloadTemplate | undefined; +}; + +/** + * Describes the message openshell.v1.SandboxTemplateResponse. + * Use `create(SandboxTemplateResponseSchema)` to create a new message. + */ +export const SandboxTemplateResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 40); + +/** + * @generated from message openshell.v1.ListSandboxTemplatesResponse + */ +export type ListSandboxTemplatesResponse = Message<"openshell.v1.ListSandboxTemplatesResponse"> & { + /** + * @generated from field: repeated openshell.v1.SandboxWorkloadTemplate templates = 1; + */ + templates: SandboxWorkloadTemplate[]; + + /** + * Token for the next page. Empty when there are no subsequent pages. + * + * @generated from field: string next_page_token = 2; + */ + nextPageToken: string; +}; + +/** + * Describes the message openshell.v1.ListSandboxTemplatesResponse. + * Use `create(ListSandboxTemplatesResponseSchema)` to create a new message. + */ +export const ListSandboxTemplatesResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 41); + +/** + * @generated from message openshell.v1.DeleteSandboxTemplateResponse + */ +export type DeleteSandboxTemplateResponse = Message<"openshell.v1.DeleteSandboxTemplateResponse"> & { + /** + * @generated from field: openshell.v1.DeletionOutcome outcome = 2; + */ + outcome: DeletionOutcome; +}; + +/** + * Describes the message openshell.v1.DeleteSandboxTemplateResponse. + * Use `create(DeleteSandboxTemplateResponseSchema)` to create a new message. + */ +export const DeleteSandboxTemplateResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 42); + +/** + * Request a gateway-owned staging slot for a local rootfs tar archive. + * + * @generated from message openshell.v1.BeginRootfsTarStagingRequest + */ +export type BeginRootfsTarStagingRequest = Message<"openshell.v1.BeginRootfsTarStagingRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 3; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * Base file name of the local archive. The gateway uses it only to name the + * staged file; path separators and traversal components are rejected. + * + * @generated from field: string file_name = 1; + */ + fileName: string; + + /** + * Size of the local archive in bytes, checked against the driver limit + * before the gateway allocates a slot. + * + * @generated from field: uint64 size_bytes = 2; + */ + sizeBytes: bigint; +}; + +/** + * Describes the message openshell.v1.BeginRootfsTarStagingRequest. + * Use `create(BeginRootfsTarStagingRequestSchema)` to create a new message. + */ +export const BeginRootfsTarStagingRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 43); + +/** + * Gateway-issued staging slot. + * + * @generated from message openshell.v1.BeginRootfsTarStagingResponse + */ +export type BeginRootfsTarStagingResponse = Message<"openshell.v1.BeginRootfsTarStagingResponse"> & { + /** + * Opaque single-use token. Pass it as + * `template.driver_config..rootfs_tar_staging_token` on + * CreateSandbox. The first CreateSandbox presenting it consumes it. + * + * @generated from field: string staging_token = 1; + */ + stagingToken: string; + + /** + * Absolute path on the gateway host the client must write the archive to. + * + * @generated from field: string upload_path = 2; + */ + uploadPath: string; + + /** + * Maximum accepted archive size in bytes, enforced again by the driver. + * + * @generated from field: uint64 max_bytes = 3; + */ + maxBytes: bigint; + + /** + * Wall-clock deadline after which the gateway reclaims the slot. + * + * @generated from field: google.protobuf.Timestamp expiration_time = 104; + */ + expirationTime?: Timestamp | undefined; +}; + +/** + * Describes the message openshell.v1.BeginRootfsTarStagingResponse. + * Use `create(BeginRootfsTarStagingResponseSchema)` to create a new message. + */ +export const BeginRootfsTarStagingResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 44); + +/** + * Get sandbox request. + * + * @generated from message openshell.v1.GetSandboxRequest + */ +export type GetSandboxRequest = Message<"openshell.v1.GetSandboxRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 2; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: string name = 1; + */ + name: string; +}; + +/** + * Describes the message openshell.v1.GetSandboxRequest. + * Use `create(GetSandboxRequestSchema)` to create a new message. + */ +export const GetSandboxRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 45); + +/** + * List sandboxes request. + * + * @generated from message openshell.v1.ListSandboxesRequest + */ +export type ListSandboxesRequest = Message<"openshell.v1.ListSandboxesRequest"> & { + /** + * Workspace scope. Named and all-workspaces selections are accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 4; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * The maximum number of sandboxes to return. Zero uses 100. Values above + * 1000 are coerced to 1000; negative values are invalid. + * + * @generated from field: int32 page_size = 1; + */ + pageSize: number; + + /** + * Token from a previous ListSandboxes response. All other request parameters + * except page_size must match the request that produced it. + * + * @generated from field: string page_token = 2; + */ + pageToken: string; + + /** + * Optional label selector for filtering (format: "key1=value1,key2=value2"). + * + * @generated from field: string label_selector = 3; + */ + labelSelector: string; +}; + +/** + * Describes the message openshell.v1.ListSandboxesRequest. + * Use `create(ListSandboxesRequestSchema)` to create a new message. + */ +export const ListSandboxesRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 46); + +/** + * List providers attached to a sandbox request. + * + * @generated from message openshell.v1.ListSandboxProvidersRequest + */ +export type ListSandboxProvidersRequest = Message<"openshell.v1.ListSandboxProvidersRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 2; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: string sandbox = 1; + */ + sandbox: string; + + /** + * The maximum number of providers to return. Zero uses 100. Values above + * 1000 are coerced to 1000; negative values are invalid. + * + * @generated from field: int32 page_size = 3; + */ + pageSize: number; + + /** + * Token from a previous ListSandboxProviders response. All other request + * parameters except page_size must match the request that produced it. + * + * @generated from field: string page_token = 4; + */ + pageToken: string; +}; + +/** + * Describes the message openshell.v1.ListSandboxProvidersRequest. + * Use `create(ListSandboxProvidersRequestSchema)` to create a new message. + */ +export const ListSandboxProvidersRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 47); + +/** + * Attach provider to sandbox request. + * + * @generated from message openshell.v1.AttachSandboxProviderRequest + */ +export type AttachSandboxProviderRequest = Message<"openshell.v1.AttachSandboxProviderRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 4; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: string sandbox = 1; + */ + sandbox: string; + + /** + * Provider name to attach. + * + * @generated from field: string provider = 2; + */ + provider: string; + + /** + * Expected resource version for optimistic concurrency control. + * If 0, the server uses the current version (backward compatibility). + * If non-zero, the server validates that the sandbox's current resource_version + * matches this value before applying the mutation, returning ABORTED on mismatch. + * + * @generated from field: uint64 expected_resource_version = 3; + */ + expectedResourceVersion: bigint; + + /** + * Optional nonzero UUID for durable at-most-once admission. Successful results + * can be replayed for 24 hours; see the API errors and retries reference. + * + * @generated from field: string request_id = 5; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.AttachSandboxProviderRequest. + * Use `create(AttachSandboxProviderRequestSchema)` to create a new message. + */ +export const AttachSandboxProviderRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 48); + +/** + * Detach provider from sandbox request. + * + * @generated from message openshell.v1.DetachSandboxProviderRequest + */ +export type DetachSandboxProviderRequest = Message<"openshell.v1.DetachSandboxProviderRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 4; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: string sandbox = 1; + */ + sandbox: string; + + /** + * Provider name to detach. + * + * @generated from field: string provider = 2; + */ + provider: string; + + /** + * Expected resource version for optimistic concurrency control. + * If 0, the server uses the current version (backward compatibility). + * If non-zero, the server validates that the sandbox's current resource_version + * matches this value before applying the mutation, returning ABORTED on mismatch. + * + * @generated from field: uint64 expected_resource_version = 3; + */ + expectedResourceVersion: bigint; + + /** + * Optional nonzero UUID for durable at-most-once admission. Successful results + * can be replayed for 24 hours; see the API errors and retries reference. + * + * @generated from field: string request_id = 5; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.DetachSandboxProviderRequest. + * Use `create(DetachSandboxProviderRequestSchema)` to create a new message. + */ +export const DetachSandboxProviderRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 49); + +/** + * Delete sandbox request. + * + * @generated from message openshell.v1.DeleteSandboxRequest + */ +export type DeleteSandboxRequest = Message<"openshell.v1.DeleteSandboxRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 2; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * Canonical sandbox name. + * + * @generated from field: string name = 1; + */ + name: string; + + /** + * Succeed with ALREADY_ABSENT if the target is missing. Does not wait for + * asynchronous cleanup and does not suppress authorization or parent errors. + * + * @generated from field: bool allow_missing = 3; + */ + allowMissing: boolean; + + /** + * Optional nonzero UUID for durable at-most-once admission. Successful results + * can be replayed for 24 hours; see the API errors and retries reference. + * + * @generated from field: string request_id = 4; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.DeleteSandboxRequest. + * Use `create(DeleteSandboxRequestSchema)` to create a new message. + */ +export const DeleteSandboxRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 50); + +/** + * Stop sandbox request. + * + * @generated from message openshell.v1.StopSandboxRequest + */ +export type StopSandboxRequest = Message<"openshell.v1.StopSandboxRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 2; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: string name = 1; + */ + name: string; + + /** + * Optional nonzero UUID for durable at-most-once admission. Successful results + * can be replayed for 24 hours; see the API errors and retries reference. + * + * @generated from field: string request_id = 3; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.StopSandboxRequest. + * Use `create(StopSandboxRequestSchema)` to create a new message. + */ +export const StopSandboxRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 51); + +/** + * Start sandbox request. + * + * @generated from message openshell.v1.StartSandboxRequest + */ +export type StartSandboxRequest = Message<"openshell.v1.StartSandboxRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 2; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: string name = 1; + */ + name: string; + + /** + * Optional nonzero UUID for durable at-most-once admission. Successful results + * can be replayed for 24 hours; see the API errors and retries reference. + * + * @generated from field: string request_id = 3; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.StartSandboxRequest. + * Use `create(StartSandboxRequestSchema)` to create a new message. + */ +export const StartSandboxRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 52); + +/** + * Suspend sandbox request. + * + * @generated from message openshell.v1.SuspendSandboxRequest + */ +export type SuspendSandboxRequest = Message<"openshell.v1.SuspendSandboxRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 2; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: string name = 1; + */ + name: string; +}; + +/** + * Describes the message openshell.v1.SuspendSandboxRequest. + * Use `create(SuspendSandboxRequestSchema)` to create a new message. + */ +export const SuspendSandboxRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 53); + +/** + * Resume sandbox request. + * + * @generated from message openshell.v1.ResumeSandboxRequest + */ +export type ResumeSandboxRequest = Message<"openshell.v1.ResumeSandboxRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 2; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: string name = 1; + */ + name: string; + + /** + * If true, the isolation backend may boot the workload cleanly when it + * cannot restore the retained memory state. If false, resume fails instead. + * + * @generated from field: bool restart_if_restore_fails = 3; + */ + restartIfRestoreFails: boolean; +}; + +/** + * Describes the message openshell.v1.ResumeSandboxRequest. + * Use `create(ResumeSandboxRequestSchema)` to create a new message. + */ +export const ResumeSandboxRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 54); + +/** + * Sandbox response. + * + * @generated from message openshell.v1.SandboxResponse + */ +export type SandboxResponse = Message<"openshell.v1.SandboxResponse"> & { + /** + * @generated from field: openshell.v1.Sandbox sandbox = 1; + */ + sandbox?: Sandbox | undefined; + + /** + * Service URLs created by CreateSandbox, keyed by service name. The empty + * key identifies the unnamed service. Other sandbox RPCs return an empty map. + * + * @generated from field: map service_urls = 2; + */ + serviceUrls: { [key: string]: string }; +}; + +/** + * Describes the message openshell.v1.SandboxResponse. + * Use `create(SandboxResponseSchema)` to create a new message. + */ +export const SandboxResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 55); + +/** + * List sandboxes response. + * + * @generated from message openshell.v1.ListSandboxesResponse + */ +export type ListSandboxesResponse = Message<"openshell.v1.ListSandboxesResponse"> & { + /** + * @generated from field: repeated openshell.v1.Sandbox sandboxes = 1; + */ + sandboxes: Sandbox[]; + + /** + * Token for the next page. Empty when there are no subsequent pages. + * + * @generated from field: string next_page_token = 2; + */ + nextPageToken: string; +}; + +/** + * Describes the message openshell.v1.ListSandboxesResponse. + * Use `create(ListSandboxesResponseSchema)` to create a new message. + */ +export const ListSandboxesResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 56); + +/** + * List providers attached to a sandbox response. + * + * @generated from message openshell.v1.ListSandboxProvidersResponse + */ +export type ListSandboxProvidersResponse = Message<"openshell.v1.ListSandboxProvidersResponse"> & { + /** + * @generated from field: repeated openshell.datamodel.v1.Provider providers = 1; + */ + providers: Provider[]; + + /** + * Token for the next page. Empty when there are no subsequent pages. + * + * @generated from field: string next_page_token = 2; + */ + nextPageToken: string; +}; + +/** + * Describes the message openshell.v1.ListSandboxProvidersResponse. + * Use `create(ListSandboxProvidersResponseSchema)` to create a new message. + */ +export const ListSandboxProvidersResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 57); + +/** + * Attach provider to sandbox response. + * + * @generated from message openshell.v1.AttachSandboxProviderResponse + */ +export type AttachSandboxProviderResponse = Message<"openshell.v1.AttachSandboxProviderResponse"> & { + /** + * @generated from field: openshell.v1.Sandbox sandbox = 1; + */ + sandbox?: Sandbox | undefined; + + /** + * True when the provider was newly attached. False means it was already attached. + * + * @generated from field: bool attached = 2; + */ + attached: boolean; + + /** + * Persisted intent; readiness requires current supervisor observations. + * + * @generated from field: openshell.v1.ProviderMutationReceipt receipt = 3; + */ + receipt?: ProviderMutationReceipt | undefined; +}; + +/** + * Describes the message openshell.v1.AttachSandboxProviderResponse. + * Use `create(AttachSandboxProviderResponseSchema)` to create a new message. + */ +export const AttachSandboxProviderResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 58); + +/** + * Detach provider from sandbox response. + * + * @generated from message openshell.v1.DetachSandboxProviderResponse + */ +export type DetachSandboxProviderResponse = Message<"openshell.v1.DetachSandboxProviderResponse"> & { + /** + * @generated from field: openshell.v1.Sandbox sandbox = 1; + */ + sandbox?: Sandbox | undefined; + + /** + * True when the provider was removed. False means it was not attached. + * + * @generated from field: bool detached = 2; + */ + detached: boolean; + + /** + * Revocation is complete only when this receipt reports REVOKED. + * + * @generated from field: openshell.v1.ProviderMutationReceipt receipt = 3; + */ + receipt?: ProviderMutationReceipt | undefined; +}; + +/** + * Describes the message openshell.v1.DetachSandboxProviderResponse. + * Use `create(DetachSandboxProviderResponseSchema)` to create a new message. + */ +export const DetachSandboxProviderResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 59); + +/** + * Exact desired authority. Revisions are opaque identities, never ordered. + * + * @generated from message openshell.v1.ProviderDesiredIdentity + */ +export type ProviderDesiredIdentity = Message<"openshell.v1.ProviderDesiredIdentity"> & { + /** + * @generated from field: string sandbox_id = 1; + */ + sandboxId: string; + + /** + * @generated from field: string sandbox = 2; + */ + sandbox: string; + + /** + * @generated from field: string attachment_epoch = 3; + */ + attachmentEpoch: string; + + /** + * Empty for a detached provider. + * + * @generated from field: string provider_id = 4; + */ + providerId: string; + + /** + * @generated from field: uint64 provider_resource_version = 5; + */ + providerResourceVersion: bigint; + + /** + * @generated from field: uint64 provider_env_revision = 6; + */ + providerEnvRevision: bigint; + + /** + * @generated from field: uint64 config_revision = 7; + */ + configRevision: bigint; + + /** + * @generated from field: string policy_hash = 8; + */ + policyHash: string; +}; + +/** + * Describes the message openshell.v1.ProviderDesiredIdentity. + * Use `create(ProviderDesiredIdentitySchema)` to create a new message. + */ +export const ProviderDesiredIdentitySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 60); + +/** + * Identifies one component snapshot revision. Revisions are equality tokens, + * not members of one shared ordering domain. + * + * @generated from message openshell.v1.ConfigSnapshotRevision + */ +export type ConfigSnapshotRevision = Message<"openshell.v1.ConfigSnapshotRevision"> & { + /** + * @generated from oneof openshell.v1.ConfigSnapshotRevision.component + */ + component: { + /** + * @generated from field: openshell.v1.SandboxConfigRevision sandbox_config = 1; + */ + value: SandboxConfigRevision; + case: "sandboxConfig"; + } | { + /** + * @generated from field: uint64 provider_environment = 2; + */ + value: bigint; + case: "providerEnvironment"; + } | { + /** + * Complete desired authority for one sandbox-scoped provider mutation. + * + * @generated from field: openshell.v1.ProviderDesiredIdentity provider_target = 3; + */ + value: ProviderDesiredIdentity; + case: "providerTarget"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message openshell.v1.ConfigSnapshotRevision. + * Use `create(ConfigSnapshotRevisionSchema)` to create a new message. + */ +export const ConfigSnapshotRevisionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 61); + +/** + * Identity needed to correlate effective sandbox configuration with the + * policy-history row whose apply status the gateway records. + * + * @generated from message openshell.v1.SandboxConfigRevision + */ +export type SandboxConfigRevision = Message<"openshell.v1.SandboxConfigRevision"> & { + /** + * @generated from field: uint64 config_revision = 1; + */ + configRevision: bigint; + + /** + * @generated from field: uint32 policy_version = 2; + */ + policyVersion: number; + + /** + * @generated from field: openshell.sandbox.v1.PolicySource policy_source = 3; + */ + policySource: PolicySource; + + /** + * @generated from field: uint32 global_policy_version = 4; + */ + globalPolicyVersion: number; + + /** + * Monotonic revision of the sandbox-scoped settings row. This disambiguates + * setting operations whose effective config fingerprint is equality-only. + * + * @generated from field: uint64 settings_revision = 5; + */ + settingsRevision: bigint; +}; + +/** + * Describes the message openshell.v1.SandboxConfigRevision. + * Use `create(SandboxConfigRevisionSchema)` to create a new message. + */ +export const SandboxConfigRevisionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 62); + +/** + * Durable progress for one sandbox-scoped desired-state mutation. Snapshot + * contents and credentials are never stored in this resource. + * + * @generated from message openshell.v1.ConfigUpdateOperation + */ +export type ConfigUpdateOperation = Message<"openshell.v1.ConfigUpdateOperation"> & { + /** + * @generated from field: string operation_id = 1; + */ + operationId: string; + + /** + * @generated from field: string sandbox_id = 2; + */ + sandboxId: string; + + /** + * @generated from field: openshell.v1.ConfigComponent component = 3; + */ + component: ConfigComponent; + + /** + * @generated from field: openshell.v1.ConfigSnapshotRevision target_revision = 4; + */ + targetRevision?: ConfigSnapshotRevision | undefined; + + /** + * @generated from field: openshell.v1.ConfigUpdateOperationState state = 5; + */ + state: ConfigUpdateOperationState; + + /** + * @generated from field: openshell.v1.ConfigApplyOutcome outcome = 6; + */ + outcome: ConfigApplyOutcome; + + /** + * @generated from field: string sanitized_error = 7; + */ + sanitizedError: string; + + /** + * @generated from field: google.protobuf.Timestamp created_time = 108; + */ + createdTime?: Timestamp | undefined; + + /** + * @generated from field: google.protobuf.Timestamp updated_time = 109; + */ + updatedTime?: Timestamp | undefined; + + /** + * Absent until the operation reaches a terminal state. + * + * @generated from field: google.protobuf.Timestamp completed_time = 110; + */ + completedTime?: Timestamp | undefined; +}; + +/** + * Describes the message openshell.v1.ConfigUpdateOperation. + * Use `create(ConfigUpdateOperationSchema)` to create a new message. + */ +export const ConfigUpdateOperationSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 63); + +/** + * Immutable, secret-free record of one sandbox's intended provider mutation. + * + * @generated from message openshell.v1.ProviderMutationReceipt + */ +export type ProviderMutationReceipt = Message<"openshell.v1.ProviderMutationReceipt"> & { + /** + * @generated from field: string receipt_id = 1; + */ + receiptId: string; + + /** + * Shared by all sandbox receipts from one provider update. + * + * @generated from field: string mutation_id = 2; + */ + mutationId: string; + + /** + * @generated from field: string provider = 3; + */ + provider: string; + + /** + * @generated from field: string workspace = 4; + */ + workspace: string; + + /** + * @generated from field: openshell.v1.ProviderMutationKind kind = 5; + */ + kind: ProviderMutationKind; + + /** + * @generated from field: openshell.v1.ProviderDesiredIdentity desired = 6; + */ + desired?: ProviderDesiredIdentity | undefined; + + /** + * @generated from field: google.protobuf.Timestamp persisted_time = 107; + */ + persistedTime?: Timestamp | undefined; +}; + +/** + * Describes the message openshell.v1.ProviderMutationReceipt. + * Use `create(ProviderMutationReceiptSchema)` to create a new message. + */ +export const ProviderMutationReceiptSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 64); + +/** + * Installed state reported by the current supervisor. Process installation is + * acknowledged by the authenticated sandbox boundary after replacing its + * environment for future process launches. + * + * @generated from message openshell.v1.ProviderReadinessObservation + */ +export type ProviderReadinessObservation = Message<"openshell.v1.ProviderReadinessObservation"> & { + /** + * Gateway-issued identifier from the current ConnectSupervisor response. + * + * @generated from field: string session_id = 1; + */ + sessionId: string; + + /** + * Monotonic only within this connection; unrelated to revision fingerprints. + * + * @generated from field: uint64 sequence = 2; + */ + sequence: bigint; + + /** + * @generated from field: string attachment_epoch = 3; + */ + attachmentEpoch: string; + + /** + * @generated from field: uint64 provider_env_revision = 4; + */ + providerEnvRevision: bigint; + + /** + * @generated from field: uint64 config_revision = 5; + */ + configRevision: bigint; + + /** + * @generated from field: string policy_hash = 6; + */ + policyHash: string; + + /** + * @generated from field: bool credentials_installed = 7; + */ + credentialsInstalled: boolean; + + /** + * @generated from field: bool policy_active = 8; + */ + policyActive: boolean; + + /** + * @generated from field: bool launch_environment_installed = 9; + */ + launchEnvironmentInstalled: boolean; + + /** + * @generated from field: string process_instance_id = 10; + */ + processInstanceId: string; + + /** + * @generated from field: openshell.v1.ProviderReadinessReason reason = 11; + */ + reason: ProviderReadinessReason; +}; + +/** + * Describes the message openshell.v1.ProviderReadinessObservation. + * Use `create(ProviderReadinessObservationSchema)` to create a new message. + */ +export const ProviderReadinessObservationSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 65); + +/** + * Operator view of desired and observed state; contains no credential material. + * + * @generated from message openshell.v1.ProviderReadinessStatus + */ +export type ProviderReadinessStatus = Message<"openshell.v1.ProviderReadinessStatus"> & { + /** + * @generated from field: openshell.v1.ProviderMutationReceipt receipt = 1; + */ + receipt?: ProviderMutationReceipt | undefined; + + /** + * @generated from field: openshell.v1.ProviderReadinessState state = 2; + */ + state: ProviderReadinessState; + + /** + * @generated from field: openshell.v1.ProviderReadinessReason reason = 3; + */ + reason: ProviderReadinessReason; + + /** + * @generated from field: openshell.v1.ProviderReadinessObservation observed = 4; + */ + observed?: ProviderReadinessObservation | undefined; + + /** + * @generated from field: string network_instance_id = 5; + */ + networkInstanceId: string; + + /** + * Absent until the current supervisor session supplies accepted evidence. + * + * @generated from field: google.protobuf.Timestamp observed_time = 106; + */ + observedTime?: Timestamp | undefined; + + /** + * @generated from field: google.protobuf.Timestamp evaluated_time = 107; + */ + evaluatedTime?: Timestamp | undefined; + + /** + * Durable operation for the receipt, including its terminal apply outcome. + * + * @generated from field: openshell.v1.ConfigUpdateOperation operation = 8; + */ + operation?: ConfigUpdateOperation | undefined; +}; + +/** + * Describes the message openshell.v1.ProviderReadinessStatus. + * Use `create(ProviderReadinessStatusSchema)` to create a new message. + */ +export const ProviderReadinessStatusSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 66); + +/** + * Query an immutable receipt, or reconstruct the current desired state when + * receipt_id is empty. The sandbox identity must match the receipt. + * + * @generated from message openshell.v1.GetSandboxProviderStatusRequest + */ +export type GetSandboxProviderStatusRequest = Message<"openshell.v1.GetSandboxProviderStatusRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 4; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: string sandbox = 1; + */ + sandbox: string; + + /** + * @generated from field: string provider = 2; + */ + provider: string; + + /** + * @generated from field: string receipt_id = 3; + */ + receiptId: string; +}; + +/** + * Describes the message openshell.v1.GetSandboxProviderStatusRequest. + * Use `create(GetSandboxProviderStatusRequestSchema)` to create a new message. + */ +export const GetSandboxProviderStatusRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 67); + +/** + * @generated from message openshell.v1.GetSandboxProviderStatusResponse + */ +export type GetSandboxProviderStatusResponse = Message<"openshell.v1.GetSandboxProviderStatusResponse"> & { + /** + * @generated from field: openshell.v1.ProviderReadinessStatus status = 1; + */ + status?: ProviderReadinessStatus | undefined; +}; + +/** + * Describes the message openshell.v1.GetSandboxProviderStatusResponse. + * Use `create(GetSandboxProviderStatusResponseSchema)` to create a new message. + */ +export const GetSandboxProviderStatusResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 68); + +/** + * Installation evidence from the authenticated supervisor for this sandbox. + * A caller-provided instance identifier alone never establishes authority. + * + * @generated from message openshell.v1.ReportProviderReadinessRequest + */ +export type ReportProviderReadinessRequest = Message<"openshell.v1.ReportProviderReadinessRequest"> & { + /** + * @generated from field: string sandbox_id = 1; + */ + sandboxId: string; + + /** + * @generated from field: openshell.v1.ProviderReadinessObservation observation = 2; + */ + observation?: ProviderReadinessObservation | undefined; +}; + +/** + * Describes the message openshell.v1.ReportProviderReadinessRequest. + * Use `create(ReportProviderReadinessRequestSchema)` to create a new message. + */ +export const ReportProviderReadinessRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 69); + +/** + * Acknowledges accepted evidence without granting a separate session authority. + * Identical retries do not extend the evidence's original acceptance time. + * + * @generated from message openshell.v1.ReportProviderReadinessResponse + */ +export type ReportProviderReadinessResponse = Message<"openshell.v1.ReportProviderReadinessResponse"> & { + /** + * @generated from field: uint64 accepted_sequence = 1; + */ + acceptedSequence: bigint; + + /** + * @generated from field: google.protobuf.Duration report_interval = 102; + */ + reportInterval?: Duration | undefined; + + /** + * @generated from field: google.protobuf.Duration observation_ttl = 103; + */ + observationTtl?: Duration | undefined; +}; + +/** + * Describes the message openshell.v1.ReportProviderReadinessResponse. + * Use `create(ReportProviderReadinessResponseSchema)` to create a new message. + */ +export const ReportProviderReadinessResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 70); + +/** + * Delete sandbox response. + * + * @generated from message openshell.v1.DeleteSandboxResponse + */ +export type DeleteSandboxResponse = Message<"openshell.v1.DeleteSandboxResponse"> & { + /** + * @generated from field: openshell.v1.DeletionOutcome outcome = 2; + */ + outcome: DeletionOutcome; + + /** + * Immutable identity of the targeted sandbox, empty for ALREADY_ABSENT. + * A same-name replacement is not part of this deletion. + * + * @generated from field: string sandbox_id = 3; + */ + sandboxId: string; +}; + +/** + * Describes the message openshell.v1.DeleteSandboxResponse. + * Use `create(DeleteSandboxResponseSchema)` to create a new message. + */ +export const DeleteSandboxResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 71); + +/** + * Create SSH session request. + * + * @generated from message openshell.v1.CreateSshSessionRequest + */ +export type CreateSshSessionRequest = Message<"openshell.v1.CreateSshSessionRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 3; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: string sandbox = 1; + */ + sandbox: string; +}; + +/** + * Describes the message openshell.v1.CreateSshSessionRequest. + * Use `create(CreateSshSessionRequestSchema)` to create a new message. + */ +export const CreateSshSessionRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 72); + +/** + * Create SSH session response. + * + * Fields are interpolated into an SSH `ProxyCommand` string that OpenSSH + * executes through `/bin/sh -c` on the caller's workstation. Servers MUST + * uphold the charset contract below; clients MUST reject responses that + * violate it. The client's own escaping provides defense-in-depth, but + * narrow charsets close injection vectors at the trust boundary. + * + * @generated from message openshell.v1.CreateSshSessionResponse + */ +export type CreateSshSessionResponse = Message<"openshell.v1.CreateSshSessionResponse"> & { + /** + * Sandbox id. [A-Za-z0-9._-]{1,128}. + * + * @generated from field: string sandbox_id = 1; + */ + sandboxId: string; + + /** + * Session token for the gateway tunnel. URL-safe ASCII + * ([A-Za-z0-9._~+/=-]) up to 4096 bytes. No shell metacharacters or + * whitespace. + * + * @generated from field: string token = 2; + */ + token: string; + + /** + * Gateway host for SSH proxy connection. IPv4 address, bracketed IPv6 + * address, or DNS hostname (Punycode-encoded for IDN). Alphanumeric plus + * `.-:[]` only, up to 253 bytes. + * + * @generated from field: string gateway_host = 3; + */ + gatewayHost: string; + + /** + * Gateway port for SSH proxy connection. Must be in range 1..=65535. + * + * @generated from field: uint32 gateway_port = 4; + */ + gatewayPort: number; + + /** + * Gateway scheme. Must be exactly "http" or "https". + * + * @generated from field: string gateway_scheme = 5; + */ + gatewayScheme: string; + + /** + * Expected sandbox SSH host identity in OpenSSH SHA256: form. + * Stable for the sandbox's lifetime. Empty only for legacy runtimes. + * + * @generated from field: string host_key_fingerprint = 7; + */ + hostKeyFingerprint: string; + + /** + * Absolute expiry. Absence means no expiry. + * + * @generated from field: google.protobuf.Timestamp expiration_time = 108; + */ + expirationTime?: Timestamp | undefined; +}; + +/** + * Describes the message openshell.v1.CreateSshSessionResponse. + * Use `create(CreateSshSessionResponseSchema)` to create a new message. + */ +export const CreateSshSessionResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 73); + +/** + * Request to expose an HTTP service running inside a sandbox. + * + * @generated from message openshell.v1.ExposeServiceRequest + */ +export type ExposeServiceRequest = Message<"openshell.v1.ExposeServiceRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 5; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * Service name within the sandbox. + * + * @generated from field: string name = 2; + */ + name: string; + + /** + * Loopback TCP port inside the sandbox. + * + * @generated from field: uint32 target_port = 3; + */ + targetPort: number; + + /** + * Whether to print/use the browser-facing service URL. + * + * @generated from field: bool domain = 4; + */ + domain: boolean; + + /** + * @generated from field: string sandbox = 1; + */ + sandbox: string; + + /** + * Optional nonzero UUID for durable at-most-once admission. Successful results + * can be replayed for 24 hours; see the API errors and retries reference. + * + * @generated from field: string request_id = 6; + */ + requestId: string; + + /** + * Application authorization behavior. Omission resolves to STRIP. + * + * @generated from field: openshell.v1.ServiceAuthorizationMode authorization_mode = 7; + */ + authorizationMode: ServiceAuthorizationMode; +}; + +/** + * Describes the message openshell.v1.ExposeServiceRequest. + * Use `create(ExposeServiceRequestSchema)` to create a new message. + */ +export const ExposeServiceRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 74); + +/** + * Request to fetch an exposed sandbox service endpoint. + * + * @generated from message openshell.v1.GetServiceRequest + */ +export type GetServiceRequest = Message<"openshell.v1.GetServiceRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 3; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * Service name within the sandbox. Empty selects the unnamed endpoint. + * + * @generated from field: string name = 2; + */ + name: string; + + /** + * @generated from field: string sandbox = 1; + */ + sandbox: string; +}; + +/** + * Describes the message openshell.v1.GetServiceRequest. + * Use `create(GetServiceRequestSchema)` to create a new message. + */ +export const GetServiceRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 75); + +/** + * Request to list exposed sandbox service endpoints. + * + * @generated from message openshell.v1.ListServicesRequest + */ +export type ListServicesRequest = Message<"openshell.v1.ListServicesRequest"> & { + /** + * Workspace scope. Named and all-workspaces selections are accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 4; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * The maximum number of services to return. Zero uses 100. Values above + * 1000 are coerced to 1000; negative values are invalid. + * + * @generated from field: int32 page_size = 2; + */ + pageSize: number; + + /** + * Token from a previous ListServices response. All other request parameters + * except page_size must match the request that produced it. + * + * @generated from field: string page_token = 3; + */ + pageToken: string; + + /** + * Optional sandbox name. Empty lists endpoints for all sandboxes. + * + * @generated from field: string sandbox = 1; + */ + sandbox: string; +}; + +/** + * Describes the message openshell.v1.ListServicesRequest. + * Use `create(ListServicesRequestSchema)` to create a new message. + */ +export const ListServicesRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 76); + +/** + * Response containing exposed sandbox service endpoints. + * + * @generated from message openshell.v1.ListServicesResponse + */ +export type ListServicesResponse = Message<"openshell.v1.ListServicesResponse"> & { + /** + * @generated from field: repeated openshell.v1.ServiceEndpointResponse services = 1; + */ + services: ServiceEndpointResponse[]; + + /** + * Token for the next page. Empty when there are no subsequent pages. + * + * @generated from field: string next_page_token = 2; + */ + nextPageToken: string; +}; + +/** + * Describes the message openshell.v1.ListServicesResponse. + * Use `create(ListServicesResponseSchema)` to create a new message. + */ +export const ListServicesResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 77); + +/** + * Request to delete an exposed sandbox service endpoint. + * + * @generated from message openshell.v1.DeleteServiceRequest + */ +export type DeleteServiceRequest = Message<"openshell.v1.DeleteServiceRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 3; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * Service name within the sandbox. Empty selects the unnamed endpoint. + * + * @generated from field: string name = 2; + */ + name: string; + + /** + * @generated from field: string sandbox = 1; + */ + sandbox: string; + + /** + * @generated from field: bool allow_missing = 4; + */ + allowMissing: boolean; + + /** + * Optional nonzero UUID for durable at-most-once admission. Successful results + * can be replayed for 24 hours; see the API errors and retries reference. + * + * @generated from field: string request_id = 5; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.DeleteServiceRequest. + * Use `create(DeleteServiceRequestSchema)` to create a new message. + */ +export const DeleteServiceRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 78); + +/** + * Response for deleting an exposed sandbox service endpoint. + * + * @generated from message openshell.v1.DeleteServiceResponse + */ +export type DeleteServiceResponse = Message<"openshell.v1.DeleteServiceResponse"> & { + /** + * @generated from field: openshell.v1.DeletionOutcome outcome = 2; + */ + outcome: DeletionOutcome; +}; + +/** + * Describes the message openshell.v1.DeleteServiceResponse. + * Use `create(DeleteServiceResponseSchema)` to create a new message. + */ +export const DeleteServiceResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 79); + +/** + * Persisted sandbox service endpoint. + * + * @generated from message openshell.v1.ServiceEndpoint + */ +export type ServiceEndpoint = Message<"openshell.v1.ServiceEndpoint"> & { + /** + * Kubernetes-style metadata. + * + * @generated from field: openshell.datamodel.v1.ObjectMeta metadata = 1; + */ + metadata?: ObjectMeta | undefined; + + /** + * Sandbox object ID. + * + * @generated from field: string sandbox_id = 2; + */ + sandboxId: string; + + /** + * Sandbox name. + * + * @generated from field: string sandbox = 3; + */ + sandbox: string; + + /** + * Service name within the sandbox. + * + * @generated from field: string name = 4; + */ + name: string; + + /** + * Loopback TCP port inside the sandbox. + * + * @generated from field: uint32 target_port = 5; + */ + targetPort: number; + + /** + * Whether browser-facing service routing is enabled for this endpoint. + * + * @generated from field: bool domain = 6; + */ + domain: boolean; + + /** + * Effective application authorization behavior for ingress requests. + * + * @generated from field: openshell.v1.ServiceAuthorizationMode authorization_mode = 7; + */ + authorizationMode: ServiceAuthorizationMode; +}; + +/** + * Describes the message openshell.v1.ServiceEndpoint. + * Use `create(ServiceEndpointSchema)` to create a new message. + */ +export const ServiceEndpointSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 80); + +/** + * Response containing a service endpoint and, when available, its local URL. + * + * @generated from message openshell.v1.ServiceEndpointResponse + */ +export type ServiceEndpointResponse = Message<"openshell.v1.ServiceEndpointResponse"> & { + /** + * @generated from field: openshell.v1.ServiceEndpoint endpoint = 1; + */ + endpoint?: ServiceEndpoint | undefined; + + /** + * @generated from field: string url = 2; + */ + url: string; +}; + +/** + * Describes the message openshell.v1.ServiceEndpointResponse. + * Use `create(ServiceEndpointResponseSchema)` to create a new message. + */ +export const ServiceEndpointResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 81); + +/** + * Revoke SSH session request. + * + * @generated from message openshell.v1.RevokeSshSessionRequest + */ +export type RevokeSshSessionRequest = Message<"openshell.v1.RevokeSshSessionRequest"> & { + /** + * Session token to revoke. + * + * @generated from field: string token = 1; + */ + token: string; + + /** + * A missing token is NOT_FOUND unless this is true. Revoking an existing, + * already-revoked session succeeds with COMPLETED. + * + * @generated from field: bool allow_missing = 2; + */ + allowMissing: boolean; +}; + +/** + * Describes the message openshell.v1.RevokeSshSessionRequest. + * Use `create(RevokeSshSessionRequestSchema)` to create a new message. + */ +export const RevokeSshSessionRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 82); + +/** + * Revoke SSH session response. + * + * @generated from message openshell.v1.RevokeSshSessionResponse + */ +export type RevokeSshSessionResponse = Message<"openshell.v1.RevokeSshSessionResponse"> & { + /** + * @generated from field: openshell.v1.DeletionOutcome outcome = 2; + */ + outcome: DeletionOutcome; +}; + +/** + * Describes the message openshell.v1.RevokeSshSessionResponse. + * Use `create(RevokeSshSessionResponseSchema)` to create a new message. + */ +export const RevokeSshSessionResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 83); + +/** + * Execute command request. + * + * @generated from message openshell.v1.ExecSandboxRequest + */ +export type ExecSandboxRequest = Message<"openshell.v1.ExecSandboxRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 12; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * Canonical sandbox name. + * + * @generated from field: string sandbox = 1; + */ + sandbox: string; + + /** + * Command and arguments. + * + * @generated from field: repeated string command = 2; + */ + command: string[]; + + /** + * Optional working directory. + * + * @generated from field: string workdir = 3; + */ + workdir: string; + + /** + * Optional environment overrides. + * + * @generated from field: map environment = 4; + */ + environment: { [key: string]: string }; + + /** + * Optional execution timeout. Absence means no timeout. + * + * @generated from field: google.protobuf.Duration execution_timeout = 105; + */ + executionTimeout?: Duration | undefined; + + /** + * Optional stdin payload passed to the command. + * + * @generated from field: bytes stdin = 6; + */ + stdin: Uint8Array; + + /** + * Request a pseudo-terminal for the remote command. + * + * @generated from field: bool tty = 7; + */ + tty: boolean; + + /** + * Initial terminal columns (used when tty=true, 0 = use default). + * + * @generated from field: uint32 cols = 8; + */ + cols: number; + + /** + * Initial terminal rows (used when tty=true, 0 = use default). + * + * @generated from field: uint32 rows = 9; + */ + rows: number; + + /** + * Skip sourcing shell login/profile startup files before running the command. + * When false (the default), the command runs through a login shell + * (`bash -lc`) so user startup files (.bash_profile/.profile, and .bashrc if + * sourced by them) are applied. When true, the command runs without those + * files (`bash -c`), for automation that needs predictable startup behavior. + * + * @generated from field: bool no_login_shell = 10; + */ + noLoginShell: boolean; + + /** + * Optional nonzero UUID for durable launch admission. Also applies to the + * initial ExecSandboxInteractive start message. Duplicates never relaunch, + * reattach, or replay output/stdin. Unconfirmed executions remain fenced; + * confirmed terminal executions retain the fence for 24 hours. + * + * @generated from field: string request_id = 11; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.ExecSandboxRequest. + * Use `create(ExecSandboxRequestSchema)` to create a new message. + */ +export const ExecSandboxRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 84); + +/** + * One stdout chunk from a sandbox exec. + * + * @generated from message openshell.v1.ExecSandboxStdout + */ +export type ExecSandboxStdout = Message<"openshell.v1.ExecSandboxStdout"> & { + /** + * @generated from field: bytes data = 1; + */ + data: Uint8Array; +}; + +/** + * Describes the message openshell.v1.ExecSandboxStdout. + * Use `create(ExecSandboxStdoutSchema)` to create a new message. + */ +export const ExecSandboxStdoutSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 85); + +/** + * One stderr chunk from a sandbox exec. + * + * @generated from message openshell.v1.ExecSandboxStderr + */ +export type ExecSandboxStderr = Message<"openshell.v1.ExecSandboxStderr"> & { + /** + * @generated from field: bytes data = 1; + */ + data: Uint8Array; +}; + +/** + * Describes the message openshell.v1.ExecSandboxStderr. + * Use `create(ExecSandboxStderrSchema)` to create a new message. + */ +export const ExecSandboxStderrSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 86); + +/** + * Final exit status for a sandbox exec. + * + * @generated from message openshell.v1.ExecSandboxExit + */ +export type ExecSandboxExit = Message<"openshell.v1.ExecSandboxExit"> & { + /** + * @generated from field: int32 exit_code = 1; + */ + exitCode: number; +}; + +/** + * Describes the message openshell.v1.ExecSandboxExit. + * Use `create(ExecSandboxExitSchema)` to create a new message. + */ +export const ExecSandboxExitSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 87); + +/** + * One event in a sandbox exec stream. + * + * @generated from message openshell.v1.ExecSandboxEvent + */ +export type ExecSandboxEvent = Message<"openshell.v1.ExecSandboxEvent"> & { + /** + * @generated from oneof openshell.v1.ExecSandboxEvent.payload + */ + payload: { + /** + * @generated from field: openshell.v1.ExecSandboxStdout stdout = 1; + */ + value: ExecSandboxStdout; + case: "stdout"; + } | { + /** + * @generated from field: openshell.v1.ExecSandboxStderr stderr = 2; + */ + value: ExecSandboxStderr; + case: "stderr"; + } | { + /** + * @generated from field: openshell.v1.ExecSandboxExit exit = 3; + */ + value: ExecSandboxExit; + case: "exit"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message openshell.v1.ExecSandboxEvent. + * Use `create(ExecSandboxEventSchema)` to create a new message. + */ +export const ExecSandboxEventSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 88); + +/** + * Initial frame for one TCP forward stream. + * + * @generated from message openshell.v1.TcpForwardInit + */ +export type TcpForwardInit = Message<"openshell.v1.TcpForwardInit"> & { + /** + * @generated from field: string sandbox = 1; + */ + sandbox: string; + + /** + * @generated from field: string workspace = 3; + */ + workspace: string; + + /** + * Optional service identifier for audit/correlation. + * + * @generated from field: string service_id = 4; + */ + serviceId: string; + + /** + * Target the gateway should request from the supervisor. + * + * @generated from oneof openshell.v1.TcpForwardInit.target + */ + target: { + /** + * @generated from field: openshell.v1.SshRelayTarget ssh = 5; + */ + value: SshRelayTarget; + case: "ssh"; + } | { + /** + * @generated from field: openshell.v1.TcpRelayTarget tcp = 6; + */ + value: TcpRelayTarget; + case: "tcp"; + } | { case: undefined; value?: undefined }; + + /** + * Optional target-specific authorization token. SSH targets use this as the + * short-lived SSH session token issued by CreateSshSession. + * + * @generated from field: string authorization_token = 7; + */ + authorizationToken: string; +}; + +/** + * Describes the message openshell.v1.TcpForwardInit. + * Use `create(TcpForwardInitSchema)` to create a new message. + */ +export const TcpForwardInitSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 89); + +/** + * A single frame on the CLI-to-gateway TCP forward stream. + * + * @generated from message openshell.v1.TcpForwardFrame + */ +export type TcpForwardFrame = Message<"openshell.v1.TcpForwardFrame"> & { + /** + * @generated from oneof openshell.v1.TcpForwardFrame.payload + */ + payload: { + /** + * @generated from field: openshell.v1.TcpForwardInit init = 1; + */ + value: TcpForwardInit; + case: "init"; + } | { + /** + * @generated from field: bytes data = 2; + */ + value: Uint8Array; + case: "data"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message openshell.v1.TcpForwardFrame. + * Use `create(TcpForwardFrameSchema)` to create a new message. + */ +export const TcpForwardFrameSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 90); + +/** + * Client-to-server message for interactive exec. + * + * @generated from message openshell.v1.ExecSandboxInput + */ +export type ExecSandboxInput = Message<"openshell.v1.ExecSandboxInput"> & { + /** + * @generated from oneof openshell.v1.ExecSandboxInput.payload + */ + payload: { + /** + * First message: exec request metadata. + * + * @generated from field: openshell.v1.ExecSandboxRequest start = 1; + */ + value: ExecSandboxRequest; + case: "start"; + } | { + /** + * Subsequent messages: raw stdin bytes. + * + * @generated from field: bytes stdin = 2; + */ + value: Uint8Array; + case: "stdin"; + } | { + /** + * Terminal window size change. + * + * @generated from field: openshell.v1.ExecSandboxWindowResize resize = 3; + */ + value: ExecSandboxWindowResize; + case: "resize"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message openshell.v1.ExecSandboxInput. + * Use `create(ExecSandboxInputSchema)` to create a new message. + */ +export const ExecSandboxInputSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 91); + +/** + * Terminal window resize event for interactive exec. + * + * @generated from message openshell.v1.ExecSandboxWindowResize + */ +export type ExecSandboxWindowResize = Message<"openshell.v1.ExecSandboxWindowResize"> & { + /** + * @generated from field: uint32 cols = 1; + */ + cols: number; + + /** + * @generated from field: uint32 rows = 2; + */ + rows: number; +}; + +/** + * Describes the message openshell.v1.ExecSandboxWindowResize. + * Use `create(ExecSandboxWindowResizeSchema)` to create a new message. + */ +export const ExecSandboxWindowResizeSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 92); + +/** + * SSH session record stored in persistence. + * + * @generated from message openshell.v1.SshSession + */ +export type SshSession = Message<"openshell.v1.SshSession"> & { + /** + * Kubernetes-style metadata (id, name, labels, timestamps, resource version). + * + * @generated from field: openshell.datamodel.v1.ObjectMeta metadata = 1; + */ + metadata?: ObjectMeta | undefined; + + /** + * Sandbox id. + * + * @generated from field: string sandbox_id = 2; + */ + sandboxId: string; + + /** + * Session token. + * + * @generated from field: string token = 3; + */ + token: string; + + /** + * Absolute expiry. Absence means no expiry. + * + * @generated from field: google.protobuf.Timestamp expiration_time = 104; + */ + expirationTime?: Timestamp | undefined; + + /** + * Revoked flag. + * + * @generated from field: bool revoked = 5; + */ + revoked: boolean; +}; + +/** + * Describes the message openshell.v1.SshSession. + * Use `create(SshSessionSchema)` to create a new message. + */ +export const SshSessionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 93); + +/** + * Watch sandbox request. + * + * @generated from message openshell.v1.WatchSandboxRequest + */ +export type WatchSandboxRequest = Message<"openshell.v1.WatchSandboxRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 11; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * Canonical sandbox name. + * + * @generated from field: string sandbox = 1; + */ + sandbox: string; + + /** + * Stream sandbox status snapshots. + * + * @generated from field: bool follow_status = 2; + */ + followStatus: boolean; + + /** + * Stream openshell-server process logs correlated to this sandbox. + * + * @generated from field: bool follow_logs = 3; + */ + followLogs: boolean; + + /** + * Stream platform events correlated to this sandbox. + * + * @generated from field: bool follow_events = 4; + */ + followEvents: boolean; + + /** + * Replay the last N log lines (best-effort) before following. + * + * @generated from field: uint32 log_tail_lines = 5; + */ + logTailLines: number; + + /** + * Replay the last N platform events (best-effort) before following. + * + * @generated from field: uint32 event_tail = 6; + */ + eventTail: number; + + /** + * Stop streaming once the sandbox reaches READY or a terminal result phase + * (COMPLETED, STOPPED, or ERROR). + * + * @generated from field: bool stop_on_terminal = 7; + */ + stopOnTerminal: boolean; + + /** + * Only include log lines at or after this time. Absence means no time filter. + * Applies to both tail replay and live streaming. + * + * @generated from field: google.protobuf.Timestamp since_time = 108; + */ + sinceTime?: Timestamp | undefined; + + /** + * Filter by log source (e.g. "gateway", "sandbox"). Empty means all sources. + * + * @generated from field: repeated string log_sources = 9; + */ + logSources: string[]; + + /** + * Minimum log level to include (e.g. "INFO", "WARN", "ERROR"). Empty means all levels. + * + * @generated from field: string log_min_level = 10; + */ + logMinLevel: string; + + /** + * Resume streaming after this cursor. Empty means no cursor resume: the + * server falls back to tail-limited replay controlled by log_tail_lines and + * event_tail. Otherwise set it to the highest `SandboxStreamEvent.cursor` + * already processed; the server replays only log and platform events after + * it, merged in cursor order, before resuming live delivery. If the requested + * cursor has already been trimmed from the server's buffer, the resume is + * unrecoverable and the stream terminates with OUT_OF_RANGE (see + * SandboxStreamWarning for the recoverable case). + * + * A cursor is bound to the cursor space that issued it. A gateway restart, + * teardown of the sandbox's buffers, or a reconnect to a different gateway + * replica starts a new space, and cursors from the previous one are rejected + * with OUT_OF_RANGE rather than silently suppressing live events beneath + * them. OUT_OF_RANGE is terminal for that cursor: restart the watch with an + * empty resume_after_cursor, because retrying the same token fails + * identically. A cursor this server could not have issued is rejected with + * INVALID_ARGUMENT. + * + * @generated from field: string resume_after_cursor = 12; + */ + resumeAfterCursor: string; +}; + +/** + * Describes the message openshell.v1.WatchSandboxRequest. + * Use `create(WatchSandboxRequestSchema)` to create a new message. + */ +export const WatchSandboxRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 94); + +/** + * One event in a sandbox watch stream. + * + * @generated from message openshell.v1.SandboxStreamEvent + */ +export type SandboxStreamEvent = Message<"openshell.v1.SandboxStreamEvent"> & { + /** + * @generated from oneof openshell.v1.SandboxStreamEvent.payload + */ + payload: { + /** + * Latest sandbox snapshot. + * + * @generated from field: openshell.v1.Sandbox sandbox = 1; + */ + value: Sandbox; + case: "sandbox"; + } | { + /** + * One server log line/event. + * + * @generated from field: openshell.v1.SandboxLogLine log = 2; + */ + value: SandboxLogLine; + case: "log"; + } | { + /** + * One platform event. + * + * @generated from field: openshell.v1.PlatformEvent event = 3; + */ + value: PlatformEvent; + case: "event"; + } | { + /** + * Recoverable warning from the server, e.g. messages dropped because a + * broadcast receiver lagged. The stream continues after this warning; the + * client can detect the gap from the warning itself. + * + * @generated from field: openshell.v1.SandboxStreamWarning warning = 4; + */ + value: SandboxStreamWarning; + case: "warning"; + } | { + /** + * Draft policy update notification. + * + * @generated from field: openshell.v1.DraftPolicyUpdate draft_policy_update = 5; + */ + value: DraftPolicyUpdate; + case: "draftPolicyUpdate"; + } | { case: undefined; value?: undefined }; + + /** + * Opaque position in this sandbox's cursor space, shared across the resumable + * log and platform event sources. Empty for non-resumable events (status + * snapshots, warnings). + * + * Do not parse this token; its encoding is not part of the contract. The only + * supported operation is comparing two non-empty cursors observed on the same + * stream and keeping the greater one, then passing it as + * WatchSandboxRequest.resume_after_cursor to resume without loss or + * duplication. That comparison is a plain byte-wise string comparison. It is + * well defined only within one stream: a stream never spans two cursor + * spaces, because a reset ends it. + * + * @generated from field: string cursor = 6; + */ + cursor: string; +}; + +/** + * Describes the message openshell.v1.SandboxStreamEvent. + * Use `create(SandboxStreamEventSchema)` to create a new message. + */ +export const SandboxStreamEventSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 95); + +/** + * Log line correlated to a sandbox. + * + * @generated from message openshell.v1.SandboxLogLine + */ +export type SandboxLogLine = Message<"openshell.v1.SandboxLogLine"> & { + /** + * @generated from field: string sandbox_id = 1; + */ + sandboxId: string; + + /** + * @generated from field: google.protobuf.Timestamp event_time = 102; + */ + eventTime?: Timestamp | undefined; + + /** + * @generated from field: string level = 3; + */ + level: string; + + /** + * @generated from field: string target = 4; + */ + target: string; + + /** + * @generated from field: string message = 5; + */ + message: string; + + /** + * Log source: "gateway" (server-side) or "sandbox" (supervisor). + * Empty is treated as "gateway" for backward compatibility. + * + * @generated from field: string source = 6; + */ + source: string; + + /** + * Structured key-value fields from the tracing event (e.g. dst_host, action). + * + * @generated from field: map fields = 7; + */ + fields: { [key: string]: string }; +}; + +/** + * Describes the message openshell.v1.SandboxLogLine. + * Use `create(SandboxLogLineSchema)` to create a new message. + */ +export const SandboxLogLineSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 96); + +/** + * Recoverable loss notification on a watch stream. Emitted when the server + * skips ahead after a broadcast lag instead of terminating; the stream keeps + * running. Cursors are opaque, so this message is the only signal that events + * were skipped. Unrecoverable loss (a trimmed or foreign resume cursor) is + * reported as an OUT_OF_RANGE stream status, not this message. + * + * @generated from message openshell.v1.SandboxStreamWarning + */ +export type SandboxStreamWarning = Message<"openshell.v1.SandboxStreamWarning"> & { + /** + * @generated from field: string message = 1; + */ + message: string; +}; + +/** + * Describes the message openshell.v1.SandboxStreamWarning. + * Use `create(SandboxStreamWarningSchema)` to create a new message. + */ +export const SandboxStreamWarningSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 97); + +/** + * Create provider request. + * + * @generated from message openshell.v1.CreateProviderRequest + */ +export type CreateProviderRequest = Message<"openshell.v1.CreateProviderRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 2; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: openshell.datamodel.v1.Provider provider = 1; + */ + provider?: Provider | undefined; + + /** + * Optional nonzero UUID for durable at-most-once admission. Successful results + * can be replayed for 24 hours; see the API errors and retries reference. + * + * @generated from field: string request_id = 3; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.CreateProviderRequest. + * Use `create(CreateProviderRequestSchema)` to create a new message. + */ +export const CreateProviderRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 98); + +/** + * Get provider request. + * + * @generated from message openshell.v1.GetProviderRequest + */ +export type GetProviderRequest = Message<"openshell.v1.GetProviderRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 2; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: string name = 1; + */ + name: string; +}; + +/** + * Describes the message openshell.v1.GetProviderRequest. + * Use `create(GetProviderRequestSchema)` to create a new message. + */ +export const GetProviderRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 99); + +/** + * Retrieve selected runtime credentials from one provider in one workspace. + * Refresh side effects can persist even when the complete request fails. + * + * @generated from message openshell.v1.GetProviderCredentialsRequest + */ +export type GetProviderCredentialsRequest = Message<"openshell.v1.GetProviderCredentialsRequest"> & { + /** + * Required named workspace selection; all_workspaces is not accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 1; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * Provider canonical name. + * + * @generated from field: string name = 2; + */ + name: string; + + /** + * Nonempty selection of runtime environment keys (maximum 32). + * + * @generated from field: repeated string credential_keys = 3; + */ + credentialKeys: string[]; + + /** + * Omitted/zero uses a five-minute safety margin. Maximum is 24 hours. + * + * @generated from field: google.protobuf.Duration minimum_remaining_lifetime = 4; + */ + minimumRemainingLifetime?: Duration | undefined; +}; + +/** + * Describes the message openshell.v1.GetProviderCredentialsRequest. + * Use `create(GetProviderCredentialsRequestSchema)` to create a new message. + */ +export const GetProviderCredentialsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 100); + +/** + * Usable runtime value, never gateway-only minting material. + * + * @generated from message openshell.v1.ProviderCredentialValue + */ +export type ProviderCredentialValue = Message<"openshell.v1.ProviderCredentialValue"> & { + /** + * @generated from field: string value = 1; + */ + value: string; + + /** + * Absent for credentials with no declared expiration. + * + * @generated from field: google.protobuf.Timestamp expiration_time = 2; + */ + expirationTime?: Timestamp | undefined; +}; + +/** + * Describes the message openshell.v1.ProviderCredentialValue. + * Use `create(ProviderCredentialValueSchema)` to create a new message. + */ +export const ProviderCredentialValueSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 101); + +/** + * @generated from message openshell.v1.GetProviderCredentialsResponse + */ +export type GetProviderCredentialsResponse = Message<"openshell.v1.GetProviderCredentialsResponse"> & { + /** + * All requested values or an error; no partial response. + * + * @generated from field: map credentials = 1; + */ + credentials: { [key: string]: ProviderCredentialValue }; +}; + +/** + * Describes the message openshell.v1.GetProviderCredentialsResponse. + * Use `create(GetProviderCredentialsResponseSchema)` to create a new message. + */ +export const GetProviderCredentialsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 102); + +/** + * List providers request. + * + * @generated from message openshell.v1.ListProvidersRequest + */ +export type ListProvidersRequest = Message<"openshell.v1.ListProvidersRequest"> & { + /** + * Workspace scope. Named and all-workspaces selections are accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 3; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * The maximum number of providers to return. Zero uses 100. Values above + * 1000 are coerced to 1000; negative values are invalid. + * + * @generated from field: int32 page_size = 1; + */ + pageSize: number; + + /** + * Token from a previous ListProviders response. All other request parameters + * except page_size must match the request that produced it. + * + * @generated from field: string page_token = 2; + */ + pageToken: string; + + /** + * Optional label selector for filtering (format: "key1=value1,key2=value2"). + * + * @generated from field: string label_selector = 4; + */ + labelSelector: string; +}; + +/** + * Describes the message openshell.v1.ListProvidersRequest. + * Use `create(ListProvidersRequestSchema)` to create a new message. + */ +export const ListProvidersRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 103); + +/** + * Update provider request. + * + * @generated from message openshell.v1.UpdateProviderRequest + */ +export type UpdateProviderRequest = Message<"openshell.v1.UpdateProviderRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 3; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: openshell.datamodel.v1.Provider provider = 1; + */ + provider?: Provider | undefined; + + /** + * Optional per-credential expiry timestamps to merge into the provider. + * Omitted keys are unchanged. Use clear_credential_expiration_keys to remove + * an existing expiry. + * + * @generated from field: map credential_expiration_times = 102; + */ + credentialExpirationTimes: { [key: string]: Timestamp }; + + /** + * Credential keys whose existing expiry should be removed. + * + * @generated from field: repeated string clear_credential_expiration_keys = 103; + */ + clearCredentialExpirationKeys: string[]; + + /** + * Optional nonzero UUID for durable at-most-once admission. Successful results + * can be replayed for 24 hours; see the API errors and retries reference. + * + * @generated from field: string request_id = 4; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.UpdateProviderRequest. + * Use `create(UpdateProviderRequestSchema)` to create a new message. + */ +export const UpdateProviderRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 104); + +/** + * Delete provider request. + * + * @generated from message openshell.v1.DeleteProviderRequest + */ +export type DeleteProviderRequest = Message<"openshell.v1.DeleteProviderRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 3; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: string name = 1; + */ + name: string; + + /** + * @generated from field: bool allow_missing = 4; + */ + allowMissing: boolean; + + /** + * Optional nonzero UUID for durable at-most-once admission. Successful results + * can be replayed for 24 hours; see the API errors and retries reference. + * + * @generated from field: string request_id = 5; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.DeleteProviderRequest. + * Use `create(DeleteProviderRequestSchema)` to create a new message. + */ +export const DeleteProviderRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 105); + +/** + * Provider response. + * + * @generated from message openshell.v1.ProviderResponse + */ +export type ProviderResponse = Message<"openshell.v1.ProviderResponse"> & { + /** + * @generated from field: openshell.datamodel.v1.Provider provider = 1; + */ + provider?: Provider | undefined; + + /** + * Selection-time sandbox target set for an update, with one receipt per target. + * Sandboxes attached later are outside this operation's readiness result. + * + * @generated from field: repeated openshell.v1.ProviderMutationReceipt target_receipts = 2; + */ + targetReceipts: ProviderMutationReceipt[]; + + /** + * Identifies the update even when its target set is empty. + * + * @generated from field: string mutation_id = 3; + */ + mutationId: string; +}; + +/** + * Describes the message openshell.v1.ProviderResponse. + * Use `create(ProviderResponseSchema)` to create a new message. + */ +export const ProviderResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 106); + +/** + * List providers response. + * + * @generated from message openshell.v1.ListProvidersResponse + */ +export type ListProvidersResponse = Message<"openshell.v1.ListProvidersResponse"> & { + /** + * @generated from field: repeated openshell.datamodel.v1.Provider providers = 1; + */ + providers: Provider[]; + + /** + * Token for the next page. Empty when there are no subsequent pages. + * + * @generated from field: string next_page_token = 2; + */ + nextPageToken: string; +}; + +/** + * Describes the message openshell.v1.ListProvidersResponse. + * Use `create(ListProvidersResponseSchema)` to create a new message. + */ +export const ListProvidersResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 107); + +/** + * List provider type profiles request. + * + * @generated from message openshell.v1.ListProviderProfilesRequest + */ +export type ListProviderProfilesRequest = Message<"openshell.v1.ListProviderProfilesRequest"> & { + /** + * Workspace scope. Omit for platform profiles; otherwise select one named workspace. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 3; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * The maximum number of profiles to return. Zero uses 100. Values above + * 1000 are coerced to 1000; negative values are invalid. + * + * @generated from field: int32 page_size = 1; + */ + pageSize: number; + + /** + * Token from a previous ListProviderProfiles response. All other request + * parameters except page_size must match the request that produced it. + * + * @generated from field: string page_token = 2; + */ + pageToken: string; +}; + +/** + * Describes the message openshell.v1.ListProviderProfilesRequest. + * Use `create(ListProviderProfilesRequestSchema)` to create a new message. + */ +export const ListProviderProfilesRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 108); + +/** + * Fetch provider type profile request. + * + * @generated from message openshell.v1.GetProviderProfileRequest + */ +export type GetProviderProfileRequest = Message<"openshell.v1.GetProviderProfileRequest"> & { + /** + * Workspace scope. Omit for platform profiles; otherwise select one named workspace. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 2; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: string id = 1; + */ + id: string; +}; + +/** + * Describes the message openshell.v1.GetProviderProfileRequest. + * Use `create(GetProviderProfileRequestSchema)` to create a new message. + */ +export const GetProviderProfileRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 109); + +/** + * Provider profile payload with optional source metadata for diagnostics. + * + * @generated from message openshell.v1.ProviderProfileImportItem + */ +export type ProviderProfileImportItem = Message<"openshell.v1.ProviderProfileImportItem"> & { + /** + * @generated from field: openshell.v1.ProviderProfile profile = 1; + */ + profile?: ProviderProfile | undefined; + + /** + * @generated from field: string source = 2; + */ + source: string; +}; + +/** + * Describes the message openshell.v1.ProviderProfileImportItem. + * Use `create(ProviderProfileImportItemSchema)` to create a new message. + */ +export const ProviderProfileImportItemSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 110); + +/** + * Provider profile validation diagnostic. + * + * @generated from message openshell.v1.ProviderProfileDiagnostic + */ +export type ProviderProfileDiagnostic = Message<"openshell.v1.ProviderProfileDiagnostic"> & { + /** + * @generated from field: string source = 1; + */ + source: string; + + /** + * @generated from field: string profile_id = 2; + */ + profileId: string; + + /** + * @generated from field: string field = 3; + */ + field: string; + + /** + * @generated from field: string message = 4; + */ + message: string; + + /** + * @generated from field: string severity = 5; + */ + severity: string; +}; + +/** + * Describes the message openshell.v1.ProviderProfileDiagnostic. + * Use `create(ProviderProfileDiagnosticSchema)` to create a new message. + */ +export const ProviderProfileDiagnosticSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 111); + +/** + * Endpoint selector for token grant audience overrides. + * + * @generated from message openshell.v1.ProviderCredentialTokenGrantAudienceOverride + */ +export type ProviderCredentialTokenGrantAudienceOverride = Message<"openshell.v1.ProviderCredentialTokenGrantAudienceOverride"> & { + /** + * Optional: endpoint host selector. If omitted, inherits the profile endpoint host. + * + * @generated from field: string host = 1; + */ + host: string; + + /** + * Optional: endpoint port selector. If omitted, matches the expanded profile endpoint port. + * + * @generated from field: uint32 port = 2; + */ + port: number; + + /** + * Optional: endpoint path selector. If omitted, inherits the profile endpoint path. + * + * @generated from field: string path = 3; + */ + path: string; + + /** + * Resource audience to request for matching endpoints. + * + * @generated from field: string audience = 4; + */ + audience: string; + + /** + * Optional: OAuth2 scopes to request. If omitted, inherits the token grant scopes. + * + * @generated from field: repeated string scopes = 5; + */ + scopes: string[]; +}; + +/** + * Describes the message openshell.v1.ProviderCredentialTokenGrantAudienceOverride. + * Use `create(ProviderCredentialTokenGrantAudienceOverrideSchema)` to create a new message. + */ +export const ProviderCredentialTokenGrantAudienceOverrideSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 112); + +/** + * @generated from message openshell.v1.ProviderCredentialTokenGrantSubjectToken + */ +export type ProviderCredentialTokenGrantSubjectToken = Message<"openshell.v1.ProviderCredentialTokenGrantSubjectToken"> & { + /** + * Source for the token exchange subject token. Phase one supports + * "provider_credential". + * + * @generated from field: string source = 1; + */ + source: string; + + /** + * Provider credential key that stores the subject token. + * + * @generated from field: string credential = 2; + */ + credential: string; + + /** + * OAuth2 subject_token_type. If omitted, OpenShell uses + * urn:ietf:params:oauth:token-type:access_token. + * + * @generated from field: string subject_token_type = 3; + */ + subjectTokenType: string; +}; + +/** + * Describes the message openshell.v1.ProviderCredentialTokenGrantSubjectToken. + * Use `create(ProviderCredentialTokenGrantSubjectTokenSchema)` to create a new message. + */ +export const ProviderCredentialTokenGrantSubjectTokenSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 113); + +/** + * @generated from message openshell.v1.ProviderCredentialTokenGrant + */ +export type ProviderCredentialTokenGrant = Message<"openshell.v1.ProviderCredentialTokenGrant"> & { + /** + * OAuth2 token endpoint URL (e.g., https://keycloak.example.com/realms/my-realm/protocol/openid-connect/token) + * + * @generated from field: string token_endpoint = 1; + */ + tokenEndpoint: string; + + /** + * Optional: default resource audience to request from the token service + * + * @generated from field: string audience = 2; + */ + audience: string; + + /** + * Optional: audience to request when fetching the JWT-SVID from SPIRE. + * If omitted, the sandbox derives this from token_endpoint. + * + * @generated from field: string jwt_svid_audience = 6; + */ + jwtSvidAudience: string; + + /** + * Optional: OAuth2 scopes to request + * + * @generated from field: repeated string scopes = 3; + */ + scopes: string[]; + + /** + * Optional token cache TTL override. If absent, use expires_in from the token response. + * + * @generated from field: google.protobuf.Duration cache_ttl = 104; + */ + cacheTtl?: Duration | undefined; + + /** + * Optional: endpoint-specific resource audience overrides. + * + * @generated from field: repeated openshell.v1.ProviderCredentialTokenGrantAudienceOverride audience_overrides = 5; + */ + audienceOverrides: ProviderCredentialTokenGrantAudienceOverride[]; + + /** + * Optional: OAuth2 client_assertion_type value. If omitted, OpenShell uses + * urn:ietf:params:oauth:client-assertion-type:jwt-bearer. + * + * @generated from field: string client_assertion_type = 7; + */ + clientAssertionType: string; + + /** + * Grant type. If omitted/unspecified, OpenShell treats this as client_credentials + * for backwards compatibility. + * + * @generated from field: openshell.v1.ProviderCredentialTokenGrantType grant_type = 8; + */ + grantType: ProviderCredentialTokenGrantType; + + /** + * Subject token metadata for token_exchange grants. + * + * @generated from field: openshell.v1.ProviderCredentialTokenGrantSubjectToken subject_token = 9; + */ + subjectToken?: ProviderCredentialTokenGrantSubjectToken | undefined; + + /** + * OAuth2 requested_token_type. If omitted for token_exchange, OpenShell uses + * urn:ietf:params:oauth:token-type:access_token. + * + * @generated from field: string requested_token_type = 10; + */ + requestedTokenType: string; +}; + +/** + * Describes the message openshell.v1.ProviderCredentialTokenGrant. + * Use `create(ProviderCredentialTokenGrantSchema)` to create a new message. + */ +export const ProviderCredentialTokenGrantSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 114); + +/** + * Provider credential declaration. + * + * @generated from message openshell.v1.ProviderProfileCredential + */ +export type ProviderProfileCredential = Message<"openshell.v1.ProviderProfileCredential"> & { + /** + * @generated from field: string name = 1; + */ + name: string; + + /** + * @generated from field: string description = 2; + */ + description: string; + + /** + * @generated from field: repeated string env_vars = 3; + */ + envVars: string[]; + + /** + * @generated from field: bool required = 4; + */ + required: boolean; + + /** + * @generated from field: string auth_style = 5; + */ + authStyle: string; + + /** + * @generated from field: string header_name = 6; + */ + headerName: string; + + /** + * @generated from field: string query_param = 7; + */ + queryParam: string; + + /** + * @generated from field: openshell.v1.ProviderCredentialRefresh refresh = 8; + */ + refresh?: ProviderCredentialRefresh | undefined; + + /** + * @generated from field: string path_template = 9; + */ + pathTemplate: string; + + /** + * @generated from field: openshell.v1.ProviderCredentialTokenGrant token_grant = 10; + */ + tokenGrant?: ProviderCredentialTokenGrant | undefined; + + /** + * Output-only gateway-derived endpoint authorities for resolved token grants. + * For inspected L7 requests, empty means no endpoint may obtain this grant. + * L4 injection uses selectors without checking these authorities. + * Profile-authored values are ignored; normal policies name the originating + * provider endpoint, while a global policy uses its own endpoint authorities. + * + * @generated from field: repeated string token_grant_owners = 11; + */ + tokenGrantOwners: string[]; + + /** + * Opt in to an opaque identity-bound environment placeholder for every env + * var declared by this credential. Use this only when an external credential + * updater requires one placeholder across value-only provider revisions. + * Gateway-managed refresh and token-grant credentials cannot opt in because + * they require identity-bearing handles for authorization-epoch revocation. + * + * @generated from field: bool stable_placeholder = 12; + */ + stablePlaceholder: boolean; +}; + +/** + * Describes the message openshell.v1.ProviderProfileCredential. + * Use `create(ProviderProfileCredentialSchema)` to create a new message. + */ +export const ProviderProfileCredentialSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 115); + +/** + * @generated from message openshell.v1.ProviderCredentialRefreshMaterial + */ +export type ProviderCredentialRefreshMaterial = Message<"openshell.v1.ProviderCredentialRefreshMaterial"> & { + /** + * @generated from field: string name = 1; + */ + name: string; + + /** + * @generated from field: string description = 2; + */ + description: string; + + /** + * @generated from field: bool required = 3; + */ + required: boolean; + + /** + * @generated from field: bool secret = 4; + */ + secret: boolean; +}; + +/** + * Describes the message openshell.v1.ProviderCredentialRefreshMaterial. + * Use `create(ProviderCredentialRefreshMaterialSchema)` to create a new message. + */ +export const ProviderCredentialRefreshMaterialSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 116); + +/** + * Declares that a single refresh operation mints more than one credential. + * The refresh is attached to a primary credential; each additional output + * maps a strategy-defined semantic output id to a sibling credential whose + * env_vars receive the minted value. + * + * @generated from message openshell.v1.ProviderCredentialRefreshOutput + */ +export type ProviderCredentialRefreshOutput = Message<"openshell.v1.ProviderCredentialRefreshOutput"> & { + /** + * strategy-defined semantic output id (e.g. "session_token") + * + * @generated from field: string output = 1; + */ + output: string; + + /** + * sibling credential name whose env_vars receive this output + * + * @generated from field: string credential = 2; + */ + credential: string; +}; + +/** + * Describes the message openshell.v1.ProviderCredentialRefreshOutput. + * Use `create(ProviderCredentialRefreshOutputSchema)` to create a new message. + */ +export const ProviderCredentialRefreshOutputSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 117); + +/** + * @generated from message openshell.v1.ProviderCredentialRefresh + */ +export type ProviderCredentialRefresh = Message<"openshell.v1.ProviderCredentialRefresh"> & { + /** + * @generated from field: openshell.v1.ProviderCredentialRefreshStrategy strategy = 1; + */ + strategy: ProviderCredentialRefreshStrategy; + + /** + * @generated from field: string token_url = 2; + */ + tokenUrl: string; + + /** + * @generated from field: repeated string scopes = 3; + */ + scopes: string[]; + + /** + * @generated from field: google.protobuf.Duration refresh_before = 104; + */ + refreshBefore?: Duration | undefined; + + /** + * @generated from field: google.protobuf.Duration max_lifetime = 105; + */ + maxLifetime?: Duration | undefined; + + /** + * @generated from field: repeated openshell.v1.ProviderCredentialRefreshMaterial material = 6; + */ + material: ProviderCredentialRefreshMaterial[]; + + /** + * @generated from field: repeated openshell.v1.ProviderCredentialRefreshOutput additional_outputs = 7; + */ + additionalOutputs: ProviderCredentialRefreshOutput[]; +}; + +/** + * Describes the message openshell.v1.ProviderCredentialRefresh. + * Use `create(ProviderCredentialRefreshSchema)` to create a new message. + */ +export const ProviderCredentialRefreshSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 118); + +/** + * @generated from message openshell.v1.ProviderCredentialRefreshStatus + */ +export type ProviderCredentialRefreshStatus = Message<"openshell.v1.ProviderCredentialRefreshStatus"> & { + /** + * @generated from field: string provider = 1; + */ + provider: string; + + /** + * @generated from field: string provider_id = 2; + */ + providerId: string; + + /** + * @generated from field: string credential_key = 3; + */ + credentialKey: string; + + /** + * @generated from field: openshell.v1.ProviderCredentialRefreshStrategy strategy = 4; + */ + strategy: ProviderCredentialRefreshStrategy; + + /** + * @generated from field: string status = 5; + */ + status: string; + + /** + * @generated from field: google.protobuf.Timestamp expiration_time = 106; + */ + expirationTime?: Timestamp | undefined; + + /** + * Next automatic refresh time. Absence means no automatic retry is scheduled; + * use recovery_action to determine the required recovery workflow. + * + * @generated from field: google.protobuf.Timestamp next_refresh_time = 107; + */ + nextRefreshTime?: Timestamp | undefined; + + /** + * @generated from field: google.protobuf.Timestamp last_refresh_time = 108; + */ + lastRefreshTime?: Timestamp | undefined; + + /** + * @generated from field: string last_error = 9; + */ + lastError: string; + + /** + * @generated from field: openshell.v1.ProviderCredentialRefreshRecoveryAction recovery_action = 10; + */ + recoveryAction: ProviderCredentialRefreshRecoveryAction; + + /** + * Stable gateway-owned failure identifier, for example + * "oauth_invalid_grant". This is not provider-controlled prose and + * incorporates any recognized top-level OAuth error classification. + * + * @generated from field: string failure_code = 11; + */ + failureCode: string; + + /** + * A bounded, recognized provider subtype that refines failure_code; clients + * do not need a separate provider_error field. Unknown provider-controlled + * values are not persisted or returned. + * + * @generated from field: string provider_error_subtype = 12; + */ + providerErrorSubtype: string; + + /** + * @generated from field: google.protobuf.Timestamp last_error_time = 113; + */ + lastErrorTime?: Timestamp | undefined; +}; + +/** + * Describes the message openshell.v1.ProviderCredentialRefreshStatus. + * Use `create(ProviderCredentialRefreshStatusSchema)` to create a new message. + */ +export const ProviderCredentialRefreshStatusSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 119); + +/** + * Provider profile local discovery declaration. + * + * @generated from message openshell.v1.ProviderProfileDiscovery + */ +export type ProviderProfileDiscovery = Message<"openshell.v1.ProviderProfileDiscovery"> & { + /** + * Credential names from ProviderProfile.credentials eligible for local discovery. + * + * @generated from field: repeated string credentials = 1; + */ + credentials: string[]; +}; + +/** + * Describes the message openshell.v1.ProviderProfileDiscovery. + * Use `create(ProviderProfileDiscoverySchema)` to create a new message. + */ +export const ProviderProfileDiscoverySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 120); + +/** + * @generated from message openshell.v1.GetProviderRefreshStatusRequest + */ +export type GetProviderRefreshStatusRequest = Message<"openshell.v1.GetProviderRefreshStatusRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 3; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: string provider = 1; + */ + provider: string; + + /** + * @generated from field: string credential_key = 2; + */ + credentialKey: string; +}; + +/** + * Describes the message openshell.v1.GetProviderRefreshStatusRequest. + * Use `create(GetProviderRefreshStatusRequestSchema)` to create a new message. + */ +export const GetProviderRefreshStatusRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 121); + +/** + * @generated from message openshell.v1.GetProviderRefreshStatusResponse + */ +export type GetProviderRefreshStatusResponse = Message<"openshell.v1.GetProviderRefreshStatusResponse"> & { + /** + * @generated from field: repeated openshell.v1.ProviderCredentialRefreshStatus credentials = 1; + */ + credentials: ProviderCredentialRefreshStatus[]; +}; + +/** + * Describes the message openshell.v1.GetProviderRefreshStatusResponse. + * Use `create(GetProviderRefreshStatusResponseSchema)` to create a new message. + */ +export const GetProviderRefreshStatusResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 122); + +/** + * @generated from message openshell.v1.ConfigureProviderRefreshRequest + */ +export type ConfigureProviderRefreshRequest = Message<"openshell.v1.ConfigureProviderRefreshRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 7; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: string provider = 1; + */ + provider: string; + + /** + * @generated from field: string credential_key = 2; + */ + credentialKey: string; + + /** + * @generated from field: openshell.v1.ProviderCredentialRefreshStrategy strategy = 3; + */ + strategy: ProviderCredentialRefreshStrategy; + + /** + * @generated from field: map material = 4; + */ + material: { [key: string]: string }; + + /** + * Additional material names the caller requests be stored as secrets. Every + * name must be present in material. The server also classifies secrets from + * the authoritative provider profile and refresh strategy. + * + * @generated from field: repeated string secret_material_keys = 5; + */ + secretMaterialKeys: string[]; + + /** + * @generated from field: google.protobuf.Timestamp expiration_time = 106; + */ + expirationTime?: Timestamp | undefined; + + /** + * Optional nonzero UUID for durable at-most-once admission. Successful results + * can be replayed for 24 hours; see the API errors and retries reference. + * + * @generated from field: string request_id = 8; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.ConfigureProviderRefreshRequest. + * Use `create(ConfigureProviderRefreshRequestSchema)` to create a new message. + */ +export const ConfigureProviderRefreshRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 123); + +/** + * @generated from message openshell.v1.ConfigureProviderRefreshResponse + */ +export type ConfigureProviderRefreshResponse = Message<"openshell.v1.ConfigureProviderRefreshResponse"> & { + /** + * @generated from field: openshell.v1.ProviderCredentialRefreshStatus status = 1; + */ + status?: ProviderCredentialRefreshStatus | undefined; +}; + +/** + * Describes the message openshell.v1.ConfigureProviderRefreshResponse. + * Use `create(ConfigureProviderRefreshResponseSchema)` to create a new message. + */ +export const ConfigureProviderRefreshResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 124); + +/** + * @generated from message openshell.v1.RotateProviderCredentialRequest + */ +export type RotateProviderCredentialRequest = Message<"openshell.v1.RotateProviderCredentialRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 3; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: string provider = 1; + */ + provider: string; + + /** + * @generated from field: string credential_key = 2; + */ + credentialKey: string; + + /** + * Optional nonzero UUID for durable at-most-once admission. Successful results + * can be replayed for 24 hours; see the API errors and retries reference. + * + * @generated from field: string request_id = 4; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.RotateProviderCredentialRequest. + * Use `create(RotateProviderCredentialRequestSchema)` to create a new message. + */ +export const RotateProviderCredentialRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 125); + +/** + * @generated from message openshell.v1.RotateProviderCredentialResponse + */ +export type RotateProviderCredentialResponse = Message<"openshell.v1.RotateProviderCredentialResponse"> & { + /** + * @generated from field: openshell.v1.ProviderCredentialRefreshStatus status = 1; + */ + status?: ProviderCredentialRefreshStatus | undefined; +}; + +/** + * Describes the message openshell.v1.RotateProviderCredentialResponse. + * Use `create(RotateProviderCredentialResponseSchema)` to create a new message. + */ +export const RotateProviderCredentialResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 126); + +/** + * @generated from message openshell.v1.DeleteProviderRefreshRequest + */ +export type DeleteProviderRefreshRequest = Message<"openshell.v1.DeleteProviderRefreshRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 4; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: string provider = 1; + */ + provider: string; + + /** + * @generated from field: string credential_key = 2; + */ + credentialKey: string; + + /** + * @generated from field: bool allow_missing = 5; + */ + allowMissing: boolean; + + /** + * Optional nonzero UUID for durable at-most-once admission. Successful results + * can be replayed for 24 hours; see the API errors and retries reference. + * + * @generated from field: string request_id = 6; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.DeleteProviderRefreshRequest. + * Use `create(DeleteProviderRefreshRequestSchema)` to create a new message. + */ +export const DeleteProviderRefreshRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 127); + +/** + * @generated from message openshell.v1.DeleteProviderRefreshResponse + */ +export type DeleteProviderRefreshResponse = Message<"openshell.v1.DeleteProviderRefreshResponse"> & { + /** + * @generated from field: openshell.v1.DeletionOutcome outcome = 2; + */ + outcome: DeletionOutcome; +}; + +/** + * Describes the message openshell.v1.DeleteProviderRefreshResponse. + * Use `create(DeleteProviderRefreshResponseSchema)` to create a new message. + */ +export const DeleteProviderRefreshResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 128); + +/** + * Provider type profile metadata exposed to clients. + * + * @generated from message openshell.v1.ProviderProfile + */ +export type ProviderProfile = Message<"openshell.v1.ProviderProfile"> & { + /** + * @generated from field: string id = 1; + */ + id: string; + + /** + * @generated from field: string display_name = 2; + */ + displayName: string; + + /** + * @generated from field: string description = 3; + */ + description: string; + + /** + * @generated from field: openshell.v1.ProviderProfileCategory category = 4; + */ + category: ProviderProfileCategory; + + /** + * @generated from field: repeated openshell.v1.ProviderProfileCredential credentials = 5; + */ + credentials: ProviderProfileCredential[]; + + /** + * @generated from field: repeated openshell.sandbox.v1.NetworkEndpoint endpoints = 6; + */ + endpoints: NetworkEndpoint[]; + + /** + * @generated from field: repeated openshell.sandbox.v1.NetworkBinary binaries = 7; + */ + binaries: NetworkBinary[]; + + /** + * @generated from field: bool inference_capable = 8; + */ + inferenceCapable: boolean; + + /** + * @generated from field: openshell.v1.ProviderProfileDiscovery discovery = 9; + */ + discovery?: ProviderProfileDiscovery | undefined; + + /** + * Storage resource version for custom profiles. Built-in profiles and new + * profile files use 0. Gateway responses set this for stored custom profiles. + * Update calls use this for optimistic concurrency. + * + * @generated from field: uint64 resource_version = 10; + */ + resourceVersion: bigint; + + /** + * Optional non-secret annotations attached by profile sources or importers. + * + * @generated from field: map annotations = 11; + */ + annotations: { [key: string]: string }; + + /** + * Server-set provenance: "builtin", "user", or "interceptor/{name}". + * Ignored on import/update payloads. + * + * @generated from field: string source = 12; + */ + source: string; + + /** + * Server-set visibility: "platform", "workspace", or empty for + * non-scoped sources. Ignored on import/update payloads. + * + * @generated from field: string scope = 13; + */ + scope: string; + + /** + * EXPERIMENTAL: Non-secret files rendered from provider configuration for the + * workload. This API and its behavior may change or be removed. + * + * @generated from field: repeated openshell.v1.ProviderProfileFile files = 14; + */ + files: ProviderProfileFile[]; +}; + +/** + * Describes the message openshell.v1.ProviderProfile. + * Use `create(ProviderProfileSchema)` to create a new message. + */ +export const ProviderProfileSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 129); + +/** + * EXPERIMENTAL: Provider file templates may change or be removed. + * + * @generated from message openshell.v1.ProviderProfileFile + */ +export type ProviderProfileFile = Message<"openshell.v1.ProviderProfileFile"> & { + /** + * One virtual file name below /run/openshell/providers//. + * + * @generated from field: string path = 1; + */ + path: string; + + /** + * UTF-8 template. Only {{config.KEY}} references are supported. + * + * @generated from field: string content = 2; + */ + content: string; + + /** + * Optional environment variable containing the virtual absolute path. + * + * @generated from field: string env_var = 3; + */ + envVar: string; +}; + +/** + * Describes the message openshell.v1.ProviderProfileFile. + * Use `create(ProviderProfileFileSchema)` to create a new message. + */ +export const ProviderProfileFileSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 130); + +/** + * Provider profile response. + * + * @generated from message openshell.v1.ProviderProfileResponse + */ +export type ProviderProfileResponse = Message<"openshell.v1.ProviderProfileResponse"> & { + /** + * @generated from field: openshell.v1.ProviderProfile profile = 1; + */ + profile?: ProviderProfile | undefined; +}; + +/** + * Describes the message openshell.v1.ProviderProfileResponse. + * Use `create(ProviderProfileResponseSchema)` to create a new message. + */ +export const ProviderProfileResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 131); + +/** + * List provider profiles response. + * + * @generated from message openshell.v1.ListProviderProfilesResponse + */ +export type ListProviderProfilesResponse = Message<"openshell.v1.ListProviderProfilesResponse"> & { + /** + * @generated from field: repeated openshell.v1.ProviderProfile profiles = 1; + */ + profiles: ProviderProfile[]; + + /** + * Token for the next page. Empty when there are no subsequent pages. + * + * @generated from field: string next_page_token = 2; + */ + nextPageToken: string; +}; + +/** + * Describes the message openshell.v1.ListProviderProfilesResponse. + * Use `create(ListProviderProfilesResponseSchema)` to create a new message. + */ +export const ListProviderProfilesResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 132); + +/** + * Import custom provider profiles request. + * + * @generated from message openshell.v1.ImportProviderProfilesRequest + */ +export type ImportProviderProfilesRequest = Message<"openshell.v1.ImportProviderProfilesRequest"> & { + /** + * Workspace scope. Omit for platform profiles; otherwise select one named workspace. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 2; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: repeated openshell.v1.ProviderProfileImportItem profiles = 1; + */ + profiles: ProviderProfileImportItem[]; + + /** + * Optional nonzero UUID for durable at-most-once admission. Successful results + * can be replayed for 24 hours; see the API errors and retries reference. + * + * @generated from field: string request_id = 3; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.ImportProviderProfilesRequest. + * Use `create(ImportProviderProfilesRequestSchema)` to create a new message. + */ +export const ImportProviderProfilesRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 133); + +/** + * Import custom provider profiles response. + * + * @generated from message openshell.v1.ImportProviderProfilesResponse + */ +export type ImportProviderProfilesResponse = Message<"openshell.v1.ImportProviderProfilesResponse"> & { + /** + * @generated from field: repeated openshell.v1.ProviderProfileDiagnostic diagnostics = 1; + */ + diagnostics: ProviderProfileDiagnostic[]; + + /** + * @generated from field: repeated openshell.v1.ProviderProfile profiles = 2; + */ + profiles: ProviderProfile[]; + + /** + * @generated from field: bool imported = 3; + */ + imported: boolean; +}; + +/** + * Describes the message openshell.v1.ImportProviderProfilesResponse. + * Use `create(ImportProviderProfilesResponseSchema)` to create a new message. + */ +export const ImportProviderProfilesResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 134); + +/** + * Update one custom provider profile request. + * + * @generated from message openshell.v1.UpdateProviderProfilesRequest + */ +export type UpdateProviderProfilesRequest = Message<"openshell.v1.UpdateProviderProfilesRequest"> & { + /** + * Workspace scope. Omit for platform profiles; otherwise select one named workspace. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 4; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: openshell.v1.ProviderProfileImportItem profile = 1; + */ + profile?: ProviderProfileImportItem | undefined; + + /** + * Expected storage resource version for optimistic concurrency control. + * If 0, the server uses the resource_version embedded in profile.profile. + * Updates without a non-zero version are rejected to prevent stale files from + * silently overwriting newer profile definitions. + * + * @generated from field: uint64 expected_resource_version = 2; + */ + expectedResourceVersion: bigint; + + /** + * Existing custom provider profile ID to update. The payload ID must match. + * + * @generated from field: string id = 3; + */ + id: string; + + /** + * Optional nonzero UUID for durable at-most-once admission. Successful results + * can be replayed for 24 hours; see the API errors and retries reference. + * + * @generated from field: string request_id = 5; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.UpdateProviderProfilesRequest. + * Use `create(UpdateProviderProfilesRequestSchema)` to create a new message. + */ +export const UpdateProviderProfilesRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 135); + +/** + * Update one custom provider profile response. + * + * @generated from message openshell.v1.UpdateProviderProfilesResponse + */ +export type UpdateProviderProfilesResponse = Message<"openshell.v1.UpdateProviderProfilesResponse"> & { + /** + * @generated from field: repeated openshell.v1.ProviderProfileDiagnostic diagnostics = 1; + */ + diagnostics: ProviderProfileDiagnostic[]; + + /** + * @generated from field: openshell.v1.ProviderProfile profile = 2; + */ + profile?: ProviderProfile | undefined; + + /** + * @generated from field: bool updated = 3; + */ + updated: boolean; +}; + +/** + * Describes the message openshell.v1.UpdateProviderProfilesResponse. + * Use `create(UpdateProviderProfilesResponseSchema)` to create a new message. + */ +export const UpdateProviderProfilesResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 136); + +/** + * Lint provider profiles request. + * + * @generated from message openshell.v1.LintProviderProfilesRequest + */ +export type LintProviderProfilesRequest = Message<"openshell.v1.LintProviderProfilesRequest"> & { + /** + * Workspace scope. Omit for platform profiles; otherwise select one named workspace. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 2; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: repeated openshell.v1.ProviderProfileImportItem profiles = 1; + */ + profiles: ProviderProfileImportItem[]; +}; + +/** + * Describes the message openshell.v1.LintProviderProfilesRequest. + * Use `create(LintProviderProfilesRequestSchema)` to create a new message. + */ +export const LintProviderProfilesRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 137); + +/** + * Lint provider profiles response. + * + * @generated from message openshell.v1.LintProviderProfilesResponse + */ +export type LintProviderProfilesResponse = Message<"openshell.v1.LintProviderProfilesResponse"> & { + /** + * @generated from field: repeated openshell.v1.ProviderProfileDiagnostic diagnostics = 1; + */ + diagnostics: ProviderProfileDiagnostic[]; + + /** + * @generated from field: bool valid = 2; + */ + valid: boolean; + + /** + * Clients enabling stable_placeholder check this before import or update, + * since older gateways silently discard unknown credential fields. + * + * @generated from field: bool supports_stable_placeholder = 3; + */ + supportsStablePlaceholder: boolean; +}; + +/** + * Describes the message openshell.v1.LintProviderProfilesResponse. + * Use `create(LintProviderProfilesResponseSchema)` to create a new message. + */ +export const LintProviderProfilesResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 138); + +/** + * Delete provider response. + * + * @generated from message openshell.v1.DeleteProviderResponse + */ +export type DeleteProviderResponse = Message<"openshell.v1.DeleteProviderResponse"> & { + /** + * @generated from field: openshell.v1.DeletionOutcome outcome = 2; + */ + outcome: DeletionOutcome; +}; + +/** + * Describes the message openshell.v1.DeleteProviderResponse. + * Use `create(DeleteProviderResponseSchema)` to create a new message. + */ +export const DeleteProviderResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 139); + +/** + * Delete custom provider profile request. + * + * @generated from message openshell.v1.DeleteProviderProfileRequest + */ +export type DeleteProviderProfileRequest = Message<"openshell.v1.DeleteProviderProfileRequest"> & { + /** + * Workspace scope. Omit for platform profiles; otherwise select one named workspace. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 2; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: string id = 1; + */ + id: string; + + /** + * @generated from field: bool allow_missing = 3; + */ + allowMissing: boolean; + + /** + * Optional nonzero UUID for durable at-most-once admission. Successful results + * can be replayed for 24 hours; see the API errors and retries reference. + * + * @generated from field: string request_id = 4; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.DeleteProviderProfileRequest. + * Use `create(DeleteProviderProfileRequestSchema)` to create a new message. + */ +export const DeleteProviderProfileRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 140); + +/** + * Delete custom provider profile response. + * + * @generated from message openshell.v1.DeleteProviderProfileResponse + */ +export type DeleteProviderProfileResponse = Message<"openshell.v1.DeleteProviderProfileResponse"> & { + /** + * @generated from field: openshell.v1.DeletionOutcome outcome = 2; + */ + outcome: DeletionOutcome; +}; + +/** + * Describes the message openshell.v1.DeleteProviderProfileResponse. + * Use `create(DeleteProviderProfileResponseSchema)` to create a new message. + */ +export const DeleteProviderProfileResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 141); + +/** + * Get sandbox provider environment request. + * + * @generated from message openshell.v1.GetSandboxProviderEnvironmentRequest + */ +export type GetSandboxProviderEnvironmentRequest = Message<"openshell.v1.GetSandboxProviderEnvironmentRequest"> & { + /** + * The sandbox ID. + * + * @generated from field: string sandbox_id = 1; + */ + sandboxId: string; + + /** + * Whether the requesting supervisor enforces endpoint bindings for static + * provider credentials. Gateways withhold static credential material when + * this capability is absent. + * + * @generated from field: bool supports_static_credential_bindings = 2; + */ + supportsStaticCredentialBindings: boolean; + + /** + * Whether the requesting supervisor understands stable external-placeholder + * metadata. Gateways withhold credentials that require this behavior when + * the capability is absent. + * + * @generated from field: bool supports_stable_placeholder_environment_keys = 3; + */ + supportsStablePlaceholderEnvironmentKeys: boolean; +}; + +/** + * Describes the message openshell.v1.GetSandboxProviderEnvironmentRequest. + * Use `create(GetSandboxProviderEnvironmentRequestSchema)` to create a new message. + */ +export const GetSandboxProviderEnvironmentRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 142); + +/** + * One network endpoint at which a static provider credential may be resolved. + * + * @generated from message openshell.v1.StaticCredentialEndpointBinding + */ +export type StaticCredentialEndpointBinding = Message<"openshell.v1.StaticCredentialEndpointBinding"> & { + /** + * @generated from field: string host = 1; + */ + host: string; + + /** + * @generated from field: uint32 port = 2; + */ + port: number; + + /** + * @generated from field: string path = 3; + */ + path: string; +}; + +/** + * Describes the message openshell.v1.StaticCredentialEndpointBinding. + * Use `create(StaticCredentialEndpointBindingSchema)` to create a new message. + */ +export const StaticCredentialEndpointBindingSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 143); + +/** + * Endpoint allowlist for one static provider credential environment variable. + * + * @generated from message openshell.v1.StaticCredentialBinding + */ +export type StaticCredentialBinding = Message<"openshell.v1.StaticCredentialBinding"> & { + /** + * @generated from field: repeated openshell.v1.StaticCredentialEndpointBinding endpoints = 1; + */ + endpoints: StaticCredentialEndpointBinding[]; + + /** + * Stable identity of the provider credential that produced this binding. + * Supervisors use it to retain old revision placeholders only across + * rotations of the same provider credential. + * + * @generated from field: string credential_identity = 2; + */ + credentialIdentity: string; + + /** + * Opaque gateway-issued handle for a stable credential lifecycle. When + * non-empty, supervisors keep the workload placeholder stable across value + * updates and replace only the resolver value. The handle changes when the + * sandbox, provider, credential key, endpoint authorization, or an applicable + * refresh authorization epoch changes. + * + * @generated from field: string workload_credential_handle = 3; + */ + workloadCredentialHandle: string; +}; + +/** + * Describes the message openshell.v1.StaticCredentialBinding. + * Use `create(StaticCredentialBindingSchema)` to create a new message. + */ +export const StaticCredentialBindingSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 144); + +/** + * Polling projection of ProviderEnvironmentSnapshot. The parallel maps below + * are keyed by the same environment variable names. Removed with the polling + * RPCs; new provider environment fields belong on the snapshot first. + * + * @generated from message openshell.v1.GetSandboxProviderEnvironmentResponse + */ +export type GetSandboxProviderEnvironmentResponse = Message<"openshell.v1.GetSandboxProviderEnvironmentResponse"> & { + /** + * Provider credential environment variables. + * + * @generated from field: map environment = 1; + */ + environment: { [key: string]: string }; + + /** + * Fingerprint for the provider credential inputs that produced environment. + * + * @generated from field: uint64 provider_env_revision = 2; + */ + providerEnvRevision: bigint; + + /** + * Expiration timestamps for returned environment variables. + * + * @generated from field: map credential_expiration_times = 103; + */ + credentialExpirationTimes: { [key: string]: Timestamp }; + + /** + * Dynamic credentials that require token grants or other runtime injection. + * Maps endpoint-bound provider metadata to credential metadata. + * Supervisor uses this to inject Authorization headers for token grant credentials. + * + * @generated from field: map dynamic_credentials = 4; + */ + dynamicCredentials: { [key: string]: ProviderProfileCredential }; + + /** + * Endpoint allowlists for static credential environment variables. Metadata + * can be incomplete when a provider profile is invalid; capable supervisors + * reject all static material in that snapshot while preserving independently + * endpoint-bound dynamic credentials. + * + * @generated from field: map static_credential_bindings = 5; + */ + staticCredentialBindings: { [key: string]: StaticCredentialBinding }; + + /** + * Environment variables that contain provider configuration rather than + * credentials and therefore do not require endpoint-scoped resolution. + * + * @generated from field: repeated string non_secret_environment_keys = 6; + */ + nonSecretEnvironmentKeys: string[]; + + /** + * Attachment identity captured with the returned provider records. + * + * @generated from field: string provider_attachment_epoch = 7; + */ + providerAttachmentEpoch: string; + + /** + * Effective policy identity used to derive this snapshot's endpoint bindings. + * + * @generated from field: string policy_hash = 8; + */ + policyHash: string; + + /** + * Nonzero when material was withheld; installing an empty map is not readiness. + * + * @generated from field: openshell.v1.ProviderReadinessReason readiness_reason = 9; + */ + readinessReason: ProviderReadinessReason; + + /** + * Complete desired set of non-secret managed files, keyed by absolute path. + * + * @generated from field: map files = 10; + */ + files: { [key: string]: string }; + + /** + * Credential environment variables whose opaque resolver handle remains + * stable across value-only provider revisions. These keys are still secrets; + * this metadata only selects the stable external-placeholder behavior. + * + * @generated from field: repeated string stable_placeholder_environment_keys = 11; + */ + stablePlaceholderEnvironmentKeys: string[]; + + /** + * Supporting gateways always acknowledge the stable-placeholder delivery + * contract, including responses without opted-in credentials. Supervisors + * require acknowledgment for declared or previously activated external + * stable credentials; ordinary legacy delivery does not require it. + * + * @generated from field: bool supports_stable_placeholder_environment_keys = 12; + */ + supportsStablePlaceholderEnvironmentKeys: boolean; +}; + +/** + * Describes the message openshell.v1.GetSandboxProviderEnvironmentResponse. + * Use `create(GetSandboxProviderEnvironmentResponseSchema)` to create a new message. + */ +export const GetSandboxProviderEnvironmentResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 145); + +/** + * One environment value and all metadata that shares its key. Names are unique + * within a snapshot. static_credential_binding is present exactly when + * classification is STATIC_CREDENTIAL. Snapshots that violate either rule are + * invalid. + * + * @generated from message openshell.v1.ProviderEnvironmentValue + */ +export type ProviderEnvironmentValue = Message<"openshell.v1.ProviderEnvironmentValue"> & { + /** + * @generated from field: string name = 1; + */ + name: string; + + /** + * @generated from field: string value = 2; + */ + value: string; + + /** + * @generated from field: openshell.v1.ProviderEnvironmentValueClassification classification = 4; + */ + classification: ProviderEnvironmentValueClassification; + + /** + * @generated from field: openshell.v1.StaticCredentialBinding static_credential_binding = 5; + */ + staticCredentialBinding?: StaticCredentialBinding | undefined; + + /** + * Absolute expiration time. Absence means no expiry. + * + * @generated from field: google.protobuf.Timestamp expiration_time = 3; + */ + expirationTime?: Timestamp | undefined; + + /** + * The static credential keeps one opaque resolver handle across value-only + * provider revisions. Set only for STATIC_CREDENTIAL values whose binding + * carries a workload_credential_handle. + * + * @generated from field: bool stable_placeholder = 6; + */ + stablePlaceholder: boolean; +}; + +/** + * Describes the message openshell.v1.ProviderEnvironmentValue. + * Use `create(ProviderEnvironmentValueSchema)` to create a new message. + */ +export const ProviderEnvironmentValueSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 146); + +/** + * Complete provider environment state delivered to a supervisor. This is the + * canonical provider environment shape; GetSandboxProviderEnvironmentResponse + * is its polling projection and is removed with the polling RPCs. Dynamic + * credentials are endpoint selectors rather than environment values and stay + * in their own collection. + * + * @generated from message openshell.v1.ProviderEnvironmentSnapshot + */ +export type ProviderEnvironmentSnapshot = Message<"openshell.v1.ProviderEnvironmentSnapshot"> & { + /** + * @generated from field: uint64 provider_env_revision = 1; + */ + providerEnvRevision: bigint; + + /** + * @generated from field: repeated openshell.v1.ProviderEnvironmentValue values = 2; + */ + values: ProviderEnvironmentValue[]; + + /** + * @generated from field: map dynamic_credentials = 3; + */ + dynamicCredentials: { [key: string]: ProviderProfileCredential }; + + /** + * @generated from field: string provider_attachment_epoch = 4; + */ + providerAttachmentEpoch: string; + + /** + * @generated from field: string policy_hash = 5; + */ + policyHash: string; + + /** + * @generated from field: openshell.v1.ProviderReadinessReason readiness_reason = 6; + */ + readinessReason: ProviderReadinessReason; + + /** + * Complete desired set of non-secret managed files, keyed by absolute path. + * + * @generated from field: map files = 7; + */ + files: { [key: string]: string }; +}; + +/** + * Describes the message openshell.v1.ProviderEnvironmentSnapshot. + * Use `create(ProviderEnvironmentSnapshotSchema)` to create a new message. + */ +export const ProviderEnvironmentSnapshotSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 147); + +/** + * @generated from message openshell.v1.ExchangeProviderSubjectTokenRequest + */ +export type ExchangeProviderSubjectTokenRequest = Message<"openshell.v1.ExchangeProviderSubjectTokenRequest"> & { + /** + * The sandbox ID. Must match the authenticated sandbox principal. + * + * @generated from field: string sandbox_id = 1; + */ + sandboxId: string; + + /** + * Attached provider record holding the configured subject token credential. + * + * @generated from field: string provider = 2; + */ + provider: string; + + /** + * Provider profile credential that declares the token_exchange grant. + * + * @generated from field: string credential_key = 3; + */ + credentialKey: string; + + /** + * Supervisor JWT-SVID. The gateway verifies this and uses its `sub` claim + * as the requested audience for the intermediate token. + * + * @generated from field: string supervisor_jwt_svid = 4; + */ + supervisorJwtSvid: string; +}; + +/** + * Describes the message openshell.v1.ExchangeProviderSubjectTokenRequest. + * Use `create(ExchangeProviderSubjectTokenRequestSchema)` to create a new message. + */ +export const ExchangeProviderSubjectTokenRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 148); + +/** + * @generated from message openshell.v1.ExchangeProviderSubjectTokenResponse + */ +export type ExchangeProviderSubjectTokenResponse = Message<"openshell.v1.ExchangeProviderSubjectTokenResponse"> & { + /** + * @generated from field: string access_token = 1; + */ + accessToken: string; + + /** + * @generated from field: google.protobuf.Duration expires_after = 102; + */ + expiresAfter?: Duration | undefined; + + /** + * @generated from field: string token_type = 3; + */ + tokenType: string; +}; + +/** + * Describes the message openshell.v1.ExchangeProviderSubjectTokenResponse. + * Use `create(ExchangeProviderSubjectTokenResponseSchema)` to create a new message. + */ +export const ExchangeProviderSubjectTokenResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 149); + +/** + * Update sandbox policy request. + * + * @generated from message openshell.v1.UpdateConfigRequest + */ +export type UpdateConfigRequest = Message<"openshell.v1.UpdateConfigRequest"> & { + /** + * Workspace scope. Omit for global updates; otherwise select one named workspace. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 10; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * The new policy to apply. + * + * Sandbox scope (`global=false`): + * - only network_policies may differ from create-time + * policy; static fields must match version 1. + * + * Global scope (`global=true`): + * - applies to all sandboxes in full (no merge). + * + * @generated from field: openshell.sandbox.v1.SandboxPolicy policy = 2; + */ + policy?: SandboxPolicy | undefined; + + /** + * Optional single setting key to mutate. + * + * @generated from field: string setting_key = 3; + */ + settingKey: string; + + /** + * Setting value for upsert operations. + * + * @generated from field: openshell.sandbox.v1.SettingValue setting_value = 4; + */ + settingValue?: SettingValue | undefined; + + /** + * Delete the setting key from scope. + * Sandbox-scoped deletes are rejected; only global delete is supported. + * + * @generated from field: bool delete_setting = 5; + */ + deleteSetting: boolean; + + /** + * Apply mutation at gateway-global scope. + * + * @generated from field: bool global = 6; + */ + global: boolean; + + /** + * Batched incremental policy merge operations. Sandbox-scoped only. + * + * @generated from field: repeated openshell.v1.PolicyMergeOperation merge_operations = 7; + */ + mergeOperations: PolicyMergeOperation[]; + + /** + * Expected resource version for optimistic concurrency control (sandbox-scoped only). + * If 0, the server uses the current version (backward compatibility). + * If non-zero, the server validates that the sandbox's current resource_version + * matches this value before applying the mutation, returning ABORTED on mismatch. + * Ignored for global-scoped updates. + * + * @generated from field: uint64 expected_resource_version = 8; + */ + expectedResourceVersion: bigint; + + /** + * Caller-provided annotations associated with a sandbox-scoped update. Values + * must not contain secrets; the gateway treats them as opaque metadata and does + * not interpret or verify their semantics. For policy updates, the gateway + * stores the annotations immutably with the revision and merges them into + * sandbox metadata as a convenience projection. For setting-only updates, it + * only merges them into sandbox metadata. Keys under the + * `internal.openshell.ai/` prefix are reserved for the gateway. + * + * @generated from field: map annotations = 9; + */ + annotations: { [key: string]: string }; + + /** + * Required for sandbox-scoped updates and empty for global updates. + * + * @generated from field: string sandbox = 1; + */ + sandbox: string; + + /** + * Optional nonzero UUID for durable at-most-once admission. Successful results + * can be replayed for 24 hours; see the API errors and retries reference. + * + * @generated from field: string request_id = 11; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.UpdateConfigRequest. + * Use `create(UpdateConfigRequestSchema)` to create a new message. + */ +export const UpdateConfigRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 150); + +/** + * @generated from message openshell.v1.PolicyMergeOperation + */ +export type PolicyMergeOperation = Message<"openshell.v1.PolicyMergeOperation"> & { + /** + * @generated from oneof openshell.v1.PolicyMergeOperation.operation + */ + operation: { + /** + * @generated from field: openshell.v1.AddNetworkRule add_rule = 1; + */ + value: AddNetworkRule; + case: "addRule"; + } | { + /** + * @generated from field: openshell.v1.RemoveNetworkEndpoint remove_endpoint = 2; + */ + value: RemoveNetworkEndpoint; + case: "removeEndpoint"; + } | { + /** + * @generated from field: openshell.v1.RemoveNetworkRule remove_rule = 3; + */ + value: RemoveNetworkRule; + case: "removeRule"; + } | { + /** + * @generated from field: openshell.v1.AddDenyRules add_deny_rules = 4; + */ + value: AddDenyRules; + case: "addDenyRules"; + } | { + /** + * @generated from field: openshell.v1.AddAllowRules add_allow_rules = 5; + */ + value: AddAllowRules; + case: "addAllowRules"; + } | { + /** + * @generated from field: openshell.v1.RemoveNetworkBinary remove_binary = 6; + */ + value: RemoveNetworkBinary; + case: "removeBinary"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message openshell.v1.PolicyMergeOperation. + * Use `create(PolicyMergeOperationSchema)` to create a new message. + */ +export const PolicyMergeOperationSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 151); + +/** + * @generated from message openshell.v1.AddNetworkRule + */ +export type AddNetworkRule = Message<"openshell.v1.AddNetworkRule"> & { + /** + * @generated from field: string rule_name = 1; + */ + ruleName: string; + + /** + * @generated from field: openshell.sandbox.v1.NetworkPolicyRule rule = 2; + */ + rule?: NetworkPolicyRule | undefined; +}; + +/** + * Describes the message openshell.v1.AddNetworkRule. + * Use `create(AddNetworkRuleSchema)` to create a new message. + */ +export const AddNetworkRuleSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 152); + +/** + * @generated from message openshell.v1.RemoveNetworkEndpoint + */ +export type RemoveNetworkEndpoint = Message<"openshell.v1.RemoveNetworkEndpoint"> & { + /** + * @generated from field: string rule_name = 1; + */ + ruleName: string; + + /** + * @generated from field: string host = 2; + */ + host: string; + + /** + * @generated from field: uint32 port = 3; + */ + port: number; +}; + +/** + * Describes the message openshell.v1.RemoveNetworkEndpoint. + * Use `create(RemoveNetworkEndpointSchema)` to create a new message. + */ +export const RemoveNetworkEndpointSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 153); + +/** + * @generated from message openshell.v1.RemoveNetworkRule + */ +export type RemoveNetworkRule = Message<"openshell.v1.RemoveNetworkRule"> & { + /** + * @generated from field: string rule_name = 1; + */ + ruleName: string; +}; + +/** + * Describes the message openshell.v1.RemoveNetworkRule. + * Use `create(RemoveNetworkRuleSchema)` to create a new message. + */ +export const RemoveNetworkRuleSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 154); + +/** + * Exact endpoint and complete authorization scope affected by an L7 append. + * All ports and binaries must match the stored target; omitted scope is invalid. + * + * @generated from message openshell.v1.L7RuleTarget + */ +export type L7RuleTarget = Message<"openshell.v1.L7RuleTarget"> & { + /** + * @generated from field: string rule_name = 1; + */ + ruleName: string; + + /** + * @generated from field: string host = 2; + */ + host: string; + + /** + * @generated from field: repeated uint32 ports = 3; + */ + ports: number[]; + + /** + * An absent path requires a unique endpoint. An empty path selects an + * endpoint without a path selector. This is not the appended request path. + * + * @generated from field: optional string path = 4; + */ + path?: string | undefined; + + /** + * Declare either a nonempty binary list or any_binary, never both. + * + * @generated from field: repeated openshell.sandbox.v1.NetworkBinary binaries = 5; + */ + binaries: NetworkBinary[]; + + /** + * @generated from field: bool any_binary = 6; + */ + anyBinary: boolean; +}; + +/** + * Describes the message openshell.v1.L7RuleTarget. + * Use `create(L7RuleTargetSchema)` to create a new message. + */ +export const L7RuleTargetSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 155); + +/** + * @generated from message openshell.v1.AddDenyRules + */ +export type AddDenyRules = Message<"openshell.v1.AddDenyRules"> & { + /** + * @generated from field: repeated openshell.sandbox.v1.L7DenyRule deny_rules = 3; + */ + denyRules: L7DenyRule[]; + + /** + * @generated from field: openshell.v1.L7RuleTarget target = 4; + */ + target?: L7RuleTarget | undefined; +}; + +/** + * Describes the message openshell.v1.AddDenyRules. + * Use `create(AddDenyRulesSchema)` to create a new message. + */ +export const AddDenyRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 156); + +/** + * @generated from message openshell.v1.AddAllowRules + */ +export type AddAllowRules = Message<"openshell.v1.AddAllowRules"> & { + /** + * @generated from field: repeated openshell.sandbox.v1.L7Rule rules = 3; + */ + rules: L7Rule[]; + + /** + * @generated from field: openshell.v1.L7RuleTarget target = 4; + */ + target?: L7RuleTarget | undefined; +}; + +/** + * Describes the message openshell.v1.AddAllowRules. + * Use `create(AddAllowRulesSchema)` to create a new message. + */ +export const AddAllowRulesSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 157); + +/** + * @generated from message openshell.v1.RemoveNetworkBinary + */ +export type RemoveNetworkBinary = Message<"openshell.v1.RemoveNetworkBinary"> & { + /** + * @generated from field: string rule_name = 1; + */ + ruleName: string; + + /** + * @generated from field: string binary_path = 2; + */ + binaryPath: string; +}; + +/** + * Describes the message openshell.v1.RemoveNetworkBinary. + * Use `create(RemoveNetworkBinarySchema)` to create a new message. + */ +export const RemoveNetworkBinarySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 158); + +/** + * Update sandbox policy response. + * + * @generated from message openshell.v1.UpdateConfigResponse + */ +export type UpdateConfigResponse = Message<"openshell.v1.UpdateConfigResponse"> & { + /** + * Assigned policy version (monotonically increasing per sandbox). + * + * @generated from field: uint32 version = 1; + */ + version: number; + + /** + * SHA-256 hash of the serialized policy payload. + * + * @generated from field: string policy_hash = 2; + */ + policyHash: string; + + /** + * Settings revision for the scope that was modified. + * + * @generated from field: uint64 settings_revision = 3; + */ + settingsRevision: bigint; + + /** + * True when a setting delete operation removed an existing key. + * + * @generated from field: bool deleted = 4; + */ + deleted: boolean; + + /** + * Sandbox metadata annotations after the update. Empty for global updates. + * + * @generated from field: map annotations = 5; + */ + annotations: { [key: string]: string }; +}; + +/** + * Describes the message openshell.v1.UpdateConfigResponse. + * Use `create(UpdateConfigResponseSchema)` to create a new message. + */ +export const UpdateConfigResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 159); + +/** + * Get sandbox policy status request. + * + * @generated from message openshell.v1.GetSandboxPolicyStatusRequest + */ +export type GetSandboxPolicyStatusRequest = Message<"openshell.v1.GetSandboxPolicyStatusRequest"> & { + /** + * Workspace scope. Omit for global queries; otherwise select one named workspace. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 4; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * The specific policy version to query. 0 means latest. + * + * @generated from field: uint32 version = 2; + */ + version: number; + + /** + * Query global policy revisions instead of a sandbox-scoped one. + * + * @generated from field: bool global = 3; + */ + global: boolean; + + /** + * @generated from field: string sandbox = 1; + */ + sandbox: string; +}; + +/** + * Describes the message openshell.v1.GetSandboxPolicyStatusRequest. + * Use `create(GetSandboxPolicyStatusRequestSchema)` to create a new message. + */ +export const GetSandboxPolicyStatusRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 160); + +/** + * Get sandbox policy status response. + * + * @generated from message openshell.v1.GetSandboxPolicyStatusResponse + */ +export type GetSandboxPolicyStatusResponse = Message<"openshell.v1.GetSandboxPolicyStatusResponse"> & { + /** + * The queried policy revision. + * + * @generated from field: openshell.v1.SandboxPolicyRevision revision = 1; + */ + revision?: SandboxPolicyRevision | undefined; + + /** + * The currently active (loaded) policy version for this sandbox. + * + * @generated from field: uint32 active_version = 2; + */ + activeVersion: number; +}; + +/** + * Describes the message openshell.v1.GetSandboxPolicyStatusResponse. + * Use `create(GetSandboxPolicyStatusResponseSchema)` to create a new message. + */ +export const GetSandboxPolicyStatusResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 161); + +/** + * List sandbox policies request. + * + * @generated from message openshell.v1.ListSandboxPoliciesRequest + */ +export type ListSandboxPoliciesRequest = Message<"openshell.v1.ListSandboxPoliciesRequest"> & { + /** + * Workspace scope. Omit for global queries; otherwise select one named workspace. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 5; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * The maximum number of revisions to return. Zero uses 100. Values above + * 1000 are coerced to 1000; negative values are invalid. + * + * @generated from field: int32 page_size = 2; + */ + pageSize: number; + + /** + * Token from a previous ListSandboxPolicies response. All other request + * parameters except page_size must match the request that produced it. + * + * @generated from field: string page_token = 3; + */ + pageToken: string; + + /** + * List global policy revisions instead of sandbox-scoped ones. + * + * @generated from field: bool global = 4; + */ + global: boolean; + + /** + * @generated from field: string sandbox = 1; + */ + sandbox: string; +}; + +/** + * Describes the message openshell.v1.ListSandboxPoliciesRequest. + * Use `create(ListSandboxPoliciesRequestSchema)` to create a new message. + */ +export const ListSandboxPoliciesRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 162); + +/** + * List sandbox policies response. + * + * @generated from message openshell.v1.ListSandboxPoliciesResponse + */ +export type ListSandboxPoliciesResponse = Message<"openshell.v1.ListSandboxPoliciesResponse"> & { + /** + * Invalid historical payloads remain visible as failed projections so one + * legacy row cannot hide the rest of the policy history. + * + * @generated from field: repeated openshell.v1.SandboxPolicyRevision revisions = 1; + */ + revisions: SandboxPolicyRevision[]; + + /** + * Token for the next page. Empty when there are no subsequent pages. + * + * @generated from field: string next_page_token = 2; + */ + nextPageToken: string; +}; + +/** + * Describes the message openshell.v1.ListSandboxPoliciesResponse. + * Use `create(ListSandboxPoliciesResponseSchema)` to create a new message. + */ +export const ListSandboxPoliciesResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 163); + +/** + * Report policy load status (called by sandbox runtime after reload attempt). + * + * @generated from message openshell.v1.ReportPolicyStatusRequest + */ +export type ReportPolicyStatusRequest = Message<"openshell.v1.ReportPolicyStatusRequest"> & { + /** + * Sandbox id. + * + * @generated from field: string sandbox_id = 1; + */ + sandboxId: string; + + /** + * The policy version that was attempted. + * + * @generated from field: uint32 version = 2; + */ + version: number; + + /** + * Load result status. + * + * @generated from field: openshell.v1.PolicyStatus status = 3; + */ + status: PolicyStatus; + + /** + * Error message if status is FAILED. + * + * @generated from field: string load_error = 4; + */ + loadError: string; +}; + +/** + * Describes the message openshell.v1.ReportPolicyStatusRequest. + * Use `create(ReportPolicyStatusRequestSchema)` to create a new message. + */ +export const ReportPolicyStatusRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 164); + +/** + * Report policy status response. + * + * @generated from message openshell.v1.ReportPolicyStatusResponse + */ +export type ReportPolicyStatusResponse = Message<"openshell.v1.ReportPolicyStatusResponse"> & { +}; + +/** + * Describes the message openshell.v1.ReportPolicyStatusResponse. + * Use `create(ReportPolicyStatusResponseSchema)` to create a new message. + */ +export const ReportPolicyStatusResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 165); + +/** + * @generated from message openshell.v1.SandboxConfigurationAdmission + */ +export type SandboxConfigurationAdmission = Message<"openshell.v1.SandboxConfigurationAdmission"> & { + /** + * @generated from field: string instance_id = 1; + */ + instanceId: string; + + /** + * @generated from field: openshell.v1.ConfigurationAdmissionState state = 2; + */ + state: ConfigurationAdmissionState; + + /** + * @generated from field: uint32 policy_version = 3; + */ + policyVersion: number; + + /** + * @generated from field: string policy_hash = 4; + */ + policyHash: string; + + /** + * @generated from field: uint64 config_revision = 5; + */ + configRevision: bigint; + + /** + * @generated from field: uint64 provider_env_revision = 6; + */ + providerEnvRevision: bigint; + + /** + * @generated from field: string error = 7; + */ + error: string; +}; + +/** + * Describes the message openshell.v1.SandboxConfigurationAdmission. + * Use `create(SandboxConfigurationAdmissionSchema)` to create a new message. + */ +export const SandboxConfigurationAdmissionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 166); + +/** + * @generated from message openshell.v1.ReportSandboxConfigurationRequest + */ +export type ReportSandboxConfigurationRequest = Message<"openshell.v1.ReportSandboxConfigurationRequest"> & { + /** + * @generated from field: string sandbox_id = 1; + */ + sandboxId: string; + + /** + * @generated from field: openshell.v1.SandboxConfigurationAdmission admission = 2; + */ + admission?: SandboxConfigurationAdmission | undefined; + + /** + * Pending registration replaces only this previously observed instance. + * + * @generated from field: string expected_instance_id = 3; + */ + expectedInstanceId: string; +}; + +/** + * Describes the message openshell.v1.ReportSandboxConfigurationRequest. + * Use `create(ReportSandboxConfigurationRequestSchema)` to create a new message. + */ +export const ReportSandboxConfigurationRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 167); + +/** + * @generated from message openshell.v1.ReportSandboxConfigurationResponse + */ +export type ReportSandboxConfigurationResponse = Message<"openshell.v1.ReportSandboxConfigurationResponse"> & { +}; + +/** + * Describes the message openshell.v1.ReportSandboxConfigurationResponse. + * Use `create(ReportSandboxConfigurationResponseSchema)` to create a new message. + */ +export const ReportSandboxConfigurationResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 168); + +/** + * A versioned policy revision with metadata. + * + * @generated from message openshell.v1.SandboxPolicyRevision + */ +export type SandboxPolicyRevision = Message<"openshell.v1.SandboxPolicyRevision"> & { + /** + * Policy version (monotonically increasing per sandbox). + * + * @generated from field: uint32 version = 1; + */ + version: number; + + /** + * SHA-256 hash of the canonical serialized policy payload. Empty in a + * ListSandboxPolicies projection when the stored payload is invalid under + * the current schema and therefore has no trusted canonical identity. + * + * @generated from field: string policy_hash = 2; + */ + policyHash: string; + + /** + * Load status of this revision. ListSandboxPolicies reports FAILED when a + * stored historical payload is invalid under the current schema, regardless + * of its persisted sandbox load status. + * + * @generated from field: openshell.v1.PolicyStatus status = 3; + */ + status: PolicyStatus; + + /** + * Sandbox load error, or the schema-validation diagnostic for an invalid + * historical row returned by ListSandboxPolicies. + * + * @generated from field: string load_error = 4; + */ + loadError: string; + + /** + * Time when this revision was created. + * + * @generated from field: google.protobuf.Timestamp created_time = 105; + */ + createdTime?: Timestamp | undefined; + + /** + * Time when this revision was loaded by the sandbox. Absent if not loaded. + * + * @generated from field: google.protobuf.Timestamp loaded_time = 106; + */ + loadedTime?: Timestamp | undefined; + + /** + * The full policy (only populated when explicitly requested). + * + * @generated from field: openshell.sandbox.v1.SandboxPolicy policy = 7; + */ + policy?: SandboxPolicy | undefined; + + /** + * Immutable provenance supplied with this policy revision. + * + * @generated from field: map provenance = 8; + */ + provenance: { [key: string]: string }; +}; + +/** + * Describes the message openshell.v1.SandboxPolicyRevision. + * Use `create(SandboxPolicyRevisionSchema)` to create a new message. + */ +export const SandboxPolicyRevisionSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 169); + +/** + * Get sandbox logs request (one-shot fetch). + * + * @generated from message openshell.v1.GetSandboxLogsRequest + */ +export type GetSandboxLogsRequest = Message<"openshell.v1.GetSandboxLogsRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 6; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * Canonical sandbox name. + * + * @generated from field: string sandbox = 1; + */ + sandbox: string; + + /** + * Maximum number of log lines to return. 0 means use default (2000). + * + * @generated from field: uint32 lines = 2; + */ + lines: number; + + /** + * Only include logs at or after this time. Absence means no filter. + * + * @generated from field: google.protobuf.Timestamp since_time = 103; + */ + sinceTime?: Timestamp | undefined; + + /** + * Filter by log source (e.g. "gateway", "sandbox"). Empty means all sources. + * + * @generated from field: repeated string sources = 4; + */ + sources: string[]; + + /** + * Minimum log level to include (e.g. "INFO", "WARN", "ERROR"). Empty means all levels. + * + * @generated from field: string min_level = 5; + */ + minLevel: string; +}; + +/** + * Describes the message openshell.v1.GetSandboxLogsRequest. + * Use `create(GetSandboxLogsRequestSchema)` to create a new message. + */ +export const GetSandboxLogsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 170); + +/** + * Batch of log lines pushed from sandbox to server. + * + * @generated from message openshell.v1.PushSandboxLogsRequest + */ +export type PushSandboxLogsRequest = Message<"openshell.v1.PushSandboxLogsRequest"> & { + /** + * The sandbox ID. + * + * @generated from field: string sandbox_id = 1; + */ + sandboxId: string; + + /** + * Log lines to ingest. + * + * @generated from field: repeated openshell.v1.SandboxLogLine logs = 2; + */ + logs: SandboxLogLine[]; +}; + +/** + * Describes the message openshell.v1.PushSandboxLogsRequest. + * Use `create(PushSandboxLogsRequestSchema)` to create a new message. + */ +export const PushSandboxLogsRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 171); + +/** + * Push sandbox logs response. + * + * @generated from message openshell.v1.PushSandboxLogsResponse + */ +export type PushSandboxLogsResponse = Message<"openshell.v1.PushSandboxLogsResponse"> & { +}; + +/** + * Describes the message openshell.v1.PushSandboxLogsResponse. + * Use `create(PushSandboxLogsResponseSchema)` to create a new message. + */ +export const PushSandboxLogsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 172); + +/** + * Get sandbox logs response. + * + * @generated from message openshell.v1.GetSandboxLogsResponse + */ +export type GetSandboxLogsResponse = Message<"openshell.v1.GetSandboxLogsResponse"> & { + /** + * Log lines in chronological order. + * + * @generated from field: repeated openshell.v1.SandboxLogLine logs = 1; + */ + logs: SandboxLogLine[]; + + /** + * Total number of lines in the server's buffer for this sandbox. + * + * @generated from field: uint32 buffer_total = 2; + */ + bufferTotal: number; +}; + +/** + * Describes the message openshell.v1.GetSandboxLogsResponse. + * Use `create(GetSandboxLogsResponseSchema)` to create a new message. + */ +export const GetSandboxLogsResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 173); + +/** + * Envelope for supervisor-to-gateway messages on the ConnectSupervisor stream. + * + * @generated from message openshell.v1.SupervisorMessage + */ +export type SupervisorMessage = Message<"openshell.v1.SupervisorMessage"> & { + /** + * @generated from oneof openshell.v1.SupervisorMessage.payload + */ + payload: { + /** + * @generated from field: openshell.v1.SupervisorHello hello = 1; + */ + value: SupervisorHello; + case: "hello"; + } | { + /** + * @generated from field: openshell.v1.SupervisorHeartbeat heartbeat = 2; + */ + value: SupervisorHeartbeat; + case: "heartbeat"; + } | { + /** + * @generated from field: openshell.v1.RelayOpenResult relay_open_result = 3; + */ + value: RelayOpenResult; + case: "relayOpenResult"; + } | { + /** + * @generated from field: openshell.v1.RelayClose relay_close = 4; + */ + value: RelayClose; + case: "relayClose"; + } | { + /** + * @generated from field: openshell.v1.ConfigUpdateResult config_update_result = 5; + */ + value: ConfigUpdateResult; + case: "configUpdateResult"; + } | { + /** + * @generated from field: openshell.v1.SupervisorServiceAdvertisement service_advertisement = 6; + */ + value: SupervisorServiceAdvertisement; + case: "serviceAdvertisement"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message openshell.v1.SupervisorMessage. + * Use `create(SupervisorMessageSchema)` to create a new message. + */ +export const SupervisorMessageSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 174); + +/** + * Envelope for gateway-to-supervisor messages on the ConnectSupervisor stream. + * + * @generated from message openshell.v1.GatewayMessage + */ +export type GatewayMessage = Message<"openshell.v1.GatewayMessage"> & { + /** + * @generated from oneof openshell.v1.GatewayMessage.payload + */ + payload: { + /** + * @generated from field: openshell.v1.SessionAccepted session_accepted = 1; + */ + value: SessionAccepted; + case: "sessionAccepted"; + } | { + /** + * @generated from field: openshell.v1.SessionRejected session_rejected = 2; + */ + value: SessionRejected; + case: "sessionRejected"; + } | { + /** + * @generated from field: openshell.v1.GatewayHeartbeat heartbeat = 3; + */ + value: GatewayHeartbeat; + case: "heartbeat"; + } | { + /** + * @generated from field: openshell.v1.RelayOpen relay_open = 4; + */ + value: RelayOpen; + case: "relayOpen"; + } | { + /** + * @generated from field: openshell.v1.RelayClose relay_close = 5; + */ + value: RelayClose; + case: "relayClose"; + } | { + /** + * @generated from field: openshell.v1.SessionRedirect session_redirect = 6; + */ + value: SessionRedirect; + case: "sessionRedirect"; + } | { + /** + * @generated from field: openshell.v1.ConfigUpdate config_update = 7; + */ + value: ConfigUpdate; + case: "configUpdate"; + } | { + /** + * @generated from field: openshell.v1.ServiceRouteLease service_route_lease = 8; + */ + value: ServiceRouteLease; + case: "serviceRouteLease"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message openshell.v1.GatewayMessage. + * Use `create(GatewayMessageSchema)` to create a new message. + */ +export const GatewayMessageSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 175); + +/** + * Supervisor identifies itself and the sandbox it manages. + * + * @generated from message openshell.v1.SupervisorHello + */ +export type SupervisorHello = Message<"openshell.v1.SupervisorHello"> & { + /** + * Sandbox ID this supervisor manages. + * + * @generated from field: string sandbox_id = 1; + */ + sandboxId: string; + + /** + * Supervisor instance ID (e.g. boot id or process epoch). + * + * @generated from field: string instance_id = 2; + */ + instanceId: string; + + /** + * Monotonic counter scoped to instance_id. Incremented for each reconnect so + * gateways can distinguish a fresh supervisor connection from stale cleanup. + * + * @generated from field: uint64 connection_epoch = 3; + */ + connectionEpoch: bigint; + + /** + * The supervisor can report credential, policy, and launch-environment installation. + * + * @generated from field: bool supports_provider_readiness = 4; + */ + supportsProviderReadiness: boolean; + + /** + * Set when this connection follows a SessionRedirect, or dials the replica + * serving the sandbox's shared supervisor. The receiving gateway serves a + * redirected hello locally instead of redirecting again, so a disagreement + * about membership cannot bounce the supervisor between replicas. A gateway + * that is shutting down may still redirect it. + * + * @generated from field: bool redirected = 5; + */ + redirected: boolean; + + /** + * The supervisor understands SessionRedirect. Gateways never redirect a + * supervisor that does not set this. + * + * @generated from field: bool supports_session_redirect = 6; + */ + supportsSessionRedirect: boolean; + + /** + * The supervisor can receive its configuration over this stream instead of + * polling for it: it applies the bootstrap ConfigUpdate and later + * ConfigUpdate payloads, and answers each with its result and admission. + * Gateways push configuration only to supervisors that set this. + * + * @generated from field: bool supports_config_push = 7; + */ + supportsConfigPush: boolean; + + /** + * @generated from field: bool supports_service_advertisements = 8; + */ + supportsServiceAdvertisements: boolean; +}; + +/** + * Describes the message openshell.v1.SupervisorHello. + * Use `create(SupervisorHelloSchema)` to create a new message. + */ +export const SupervisorHelloSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 176); + +/** + * Gateway accepts the supervisor session. + * + * @generated from message openshell.v1.SessionAccepted + */ +export type SessionAccepted = Message<"openshell.v1.SessionAccepted"> & { + /** + * Gateway-assigned session ID for this connection. + * + * @generated from field: string session_id = 1; + */ + sessionId: string; + + /** + * The session's first configuration update. Present exactly when + * config_push_enabled is set. + * + * @generated from field: openshell.v1.ConfigUpdate bootstrap = 3; + */ + bootstrap?: ConfigUpdate | undefined; + + /** + * The gateway pushes configuration authoritatively on this stream instead + * of the supervisor polling for it: the bootstrap is required, ConfigUpdate + * payloads are applied and acknowledged, and the supervisor stops polling. + * Set only for supervisors that set SupervisorHello.supports_config_push. + * + * @generated from field: bool config_push_enabled = 4; + */ + configPushEnabled: boolean; + + /** + * Recommended heartbeat interval. + * + * @generated from field: google.protobuf.Duration heartbeat_interval = 102; + */ + heartbeatInterval?: Duration | undefined; +}; + +/** + * Describes the message openshell.v1.SessionAccepted. + * Use `create(SessionAcceptedSchema)` to create a new message. + */ +export const SessionAcceptedSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 177); + +/** + * Complete gateway-owned configuration for a supervisor session. Each update + * replaces the previous one. The supervisor applies the two parts together + * and answers every update with one ConfigUpdateResult before the gateway + * sends the next. + * + * @generated from message openshell.v1.ConfigUpdate + */ +export type ConfigUpdate = Message<"openshell.v1.ConfigUpdate"> & { + /** + * Opaque non-empty identifier scoped to the active supervisor session. + * + * @generated from field: string update_id = 1; + */ + updateId: string; + + /** + * @generated from field: openshell.sandbox.v1.SandboxConfigSnapshot sandbox_config = 2; + */ + sandboxConfig?: SandboxConfigSnapshot | undefined; + + /** + * The provider environment the sandbox configuration names through its + * provider revision, attachment epoch, and policy hash. + * + * @generated from field: openshell.v1.ProviderEnvironmentSnapshot provider_environment = 3; + */ + providerEnvironment?: ProviderEnvironmentSnapshot | undefined; +}; + +/** + * Describes the message openshell.v1.ConfigUpdate. + * Use `create(ConfigUpdateSchema)` to create a new message. + */ +export const ConfigUpdateSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 178); + +/** + * Sanitized application failure. Messages must not contain configuration + * payloads, credentials, or provider values. + * + * @generated from message openshell.v1.ConfigApplyFailure + */ +export type ConfigApplyFailure = Message<"openshell.v1.ConfigApplyFailure"> & { + /** + * @generated from field: string code = 1; + */ + code: string; + + /** + * @generated from field: string message = 2; + */ + message: string; + + /** + * @generated from field: bool retryable = 3; + */ + retryable: boolean; +}; + +/** + * Describes the message openshell.v1.ConfigApplyFailure. + * Use `create(ConfigApplyFailureSchema)` to create a new message. + */ +export const ConfigApplyFailureSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 179); + +/** + * Application result for one ConfigUpdate, including the bootstrap. + * + * @generated from message openshell.v1.ConfigUpdateResult + */ +export type ConfigUpdateResult = Message<"openshell.v1.ConfigUpdateResult"> & { + /** + * Echoes ConfigUpdate.update_id for session-local correlation. + * + * @generated from field: string update_id = 1; + */ + updateId: string; + + /** + * @generated from field: openshell.v1.ConfigApplyOutcome outcome = 2; + */ + outcome: ConfigApplyOutcome; + + /** + * Why the update did not take effect. Omitted when it did. + * + * @generated from field: openshell.v1.ConfigApplyFailure failure = 3; + */ + failure?: ConfigApplyFailure | undefined; + + /** + * Admission state of the delivered sandbox configuration. + * + * @generated from field: openshell.v1.SandboxConfigurationAdmission admission = 4; + */ + admission?: SandboxConfigurationAdmission | undefined; + + /** + * Load result of the sandbox policy revision the update changed, as a + * polling supervisor reports it with ReportPolicyStatus. Omitted when the + * update did not change the sandbox policy. + * + * @generated from field: openshell.v1.PolicyLoadResult policy_load = 5; + */ + policyLoad?: PolicyLoadResult | undefined; +}; + +/** + * Describes the message openshell.v1.ConfigUpdateResult. + * Use `create(ConfigUpdateResultSchema)` to create a new message. + */ +export const ConfigUpdateResultSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 180); + +/** + * Load result of one sandbox policy revision. + * + * @generated from message openshell.v1.PolicyLoadResult + */ +export type PolicyLoadResult = Message<"openshell.v1.PolicyLoadResult"> & { + /** + * @generated from field: uint32 version = 1; + */ + version: number; + + /** + * @generated from field: bool loaded = 2; + */ + loaded: boolean; + + /** + * Sanitized load error. Empty when loaded. + * + * @generated from field: string error = 3; + */ + error: string; +}; + +/** + * Describes the message openshell.v1.PolicyLoadResult. + * Use `create(PolicyLoadResultSchema)` to create a new message. + */ +export const PolicyLoadResultSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 181); + +/** + * Gateway rejects the supervisor session. + * + * @generated from message openshell.v1.SessionRejected + */ +export type SessionRejected = Message<"openshell.v1.SessionRejected"> & { + /** + * Human-readable rejection reason. + * + * @generated from field: string reason = 1; + */ + reason: string; +}; + +/** + * Describes the message openshell.v1.SessionRejected. + * Use `create(SessionRejectedSchema)` to create a new message. + */ +export const SessionRejectedSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 182); + +/** + * Gateway declines to own this session and names the replica that should. + * + * Sent instead of SessionAccepted when the placement ring puts the sandbox on + * a different live replica, and to established sessions when their gateway + * shuts down. The supervisor reconnects to peer_endpoint once with + * SupervisorHello.redirected set, and falls back to its configured gateway + * address if that fails. + * + * @generated from message openshell.v1.SessionRedirect + */ +export type SessionRedirect = Message<"openshell.v1.SessionRedirect"> & { + /** + * Peer endpoint of the replica that should own this sandbox. + * + * @generated from field: string peer_endpoint = 1; + */ + peerEndpoint: string; + + /** + * Replica ID that should own this sandbox, for logging. + * + * @generated from field: string owner_replica_id = 2; + */ + ownerReplicaId: string; +}; + +/** + * Describes the message openshell.v1.SessionRedirect. + * Use `create(SessionRedirectSchema)` to create a new message. + */ +export const SessionRedirectSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 183); + +/** + * Supervisor heartbeat. + * + * @generated from message openshell.v1.SupervisorHeartbeat + */ +export type SupervisorHeartbeat = Message<"openshell.v1.SupervisorHeartbeat"> & { +}; + +/** + * Describes the message openshell.v1.SupervisorHeartbeat. + * Use `create(SupervisorHeartbeatSchema)` to create a new message. + */ +export const SupervisorHeartbeatSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 184); + +/** + * Gateway heartbeat. + * + * @generated from message openshell.v1.GatewayHeartbeat + */ +export type GatewayHeartbeat = Message<"openshell.v1.GatewayHeartbeat"> & { +}; + +/** + * Describes the message openshell.v1.GatewayHeartbeat. + * Use `create(GatewayHeartbeatSchema)` to create a new message. + */ +export const GatewayHeartbeatSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 185); + +/** + * Terminal result reported before the supervisor shuts down. A successful RPC + * response confirms that the result was durably handled by the gateway. + * + * @generated from message openshell.v1.ReportMainProcessExitRequest + */ +export type ReportMainProcessExitRequest = Message<"openshell.v1.ReportMainProcessExitRequest"> & { + /** + * @generated from field: string sandbox_id = 1; + */ + sandboxId: string; + + /** + * @generated from field: string instance_id = 2; + */ + instanceId: string; + + /** + * Normalized process result. Signal exits use 128 + signal number. + * + * @generated from field: int32 exit_code = 3; + */ + exitCode: number; +}; + +/** + * Describes the message openshell.v1.ReportMainProcessExitRequest. + * Use `create(ReportMainProcessExitRequestSchema)` to create a new message. + */ +export const ReportMainProcessExitRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 186); + +/** + * @generated from message openshell.v1.ReportMainProcessExitResponse + */ +export type ReportMainProcessExitResponse = Message<"openshell.v1.ReportMainProcessExitResponse"> & { +}; + +/** + * Describes the message openshell.v1.ReportMainProcessExitResponse. + * Use `create(ReportMainProcessExitResponseSchema)` to create a new message. + */ +export const ReportMainProcessExitResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 187); + +/** + * Terminal-delivery completion reported after all expected foreground SSH + * attachments close. A successful response permits ephemeral cleanup. + * + * @generated from message openshell.v1.FinalizeMainProcessExitRequest + */ +export type FinalizeMainProcessExitRequest = Message<"openshell.v1.FinalizeMainProcessExitRequest"> & { + /** + * @generated from field: string sandbox_id = 1; + */ + sandboxId: string; + + /** + * @generated from field: string instance_id = 2; + */ + instanceId: string; +}; + +/** + * Describes the message openshell.v1.FinalizeMainProcessExitRequest. + * Use `create(FinalizeMainProcessExitRequestSchema)` to create a new message. + */ +export const FinalizeMainProcessExitRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 188); + +/** + * @generated from message openshell.v1.FinalizeMainProcessExitResponse + */ +export type FinalizeMainProcessExitResponse = Message<"openshell.v1.FinalizeMainProcessExitResponse"> & { +}; + +/** + * Describes the message openshell.v1.FinalizeMainProcessExitResponse. + * Use `create(FinalizeMainProcessExitResponseSchema)` to create a new message. + */ +export const FinalizeMainProcessExitResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 189); + +/** + * Gateway requests the supervisor to open a relay channel. + * + * On receiving this, the supervisor should initiate a RelayStream RPC to + * the gateway, sending a RelayInit in the first RelayFrame to associate + * the new HTTP/2 stream with the pending relay slot. The supervisor + * bridges that stream to the requested local target. + * + * @generated from message openshell.v1.RelayOpen + */ +export type RelayOpen = Message<"openshell.v1.RelayOpen"> & { + /** + * Gateway-allocated channel identifier (UUID). + * + * @generated from field: string channel_id = 1; + */ + channelId: string; + + /** + * Target the supervisor should dial inside the sandbox. + * If absent, supervisors treat the relay as SSH for compatibility. + * + * @generated from oneof openshell.v1.RelayOpen.target + */ + target: { + /** + * @generated from field: openshell.v1.SshRelayTarget ssh = 2; + */ + value: SshRelayTarget; + case: "ssh"; + } | { + /** + * @generated from field: openshell.v1.TcpRelayTarget tcp = 3; + */ + value: TcpRelayTarget; + case: "tcp"; + } | { case: undefined; value?: undefined }; + + /** + * Optional service identifier for audit/correlation. + * + * @generated from field: string service_id = 5; + */ + serviceId: string; +}; + +/** + * Describes the message openshell.v1.RelayOpen. + * Use `create(RelayOpenSchema)` to create a new message. + */ +export const RelayOpenSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 190); + +/** + * Built-in SSH relay target. + * + * @generated from message openshell.v1.SshRelayTarget + */ +export type SshRelayTarget = Message<"openshell.v1.SshRelayTarget"> & { +}; + +/** + * Describes the message openshell.v1.SshRelayTarget. + * Use `create(SshRelayTargetSchema)` to create a new message. + */ +export const SshRelayTargetSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 191); + +/** + * TCP target dialed by the supervisor from inside the sandbox. + * + * @generated from message openshell.v1.TcpRelayTarget + */ +export type TcpRelayTarget = Message<"openshell.v1.TcpRelayTarget"> & { + /** + * Phase 1 accepts loopback only: 127.0.0.1, ::1, or localhost. + * + * @generated from field: string host = 1; + */ + host: string; + + /** + * Target port. Must fit in u16 and be non-zero. + * + * @generated from field: uint32 port = 2; + */ + port: number; +}; + +/** + * Describes the message openshell.v1.TcpRelayTarget. + * Use `create(TcpRelayTargetSchema)` to create a new message. + */ +export const TcpRelayTargetSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 192); + +/** + * Initial RelayStream frame sent by the supervisor to claim a pending relay. + * + * @generated from message openshell.v1.RelayInit + */ +export type RelayInit = Message<"openshell.v1.RelayInit"> & { + /** + * Gateway-allocated channel identifier (UUID). + * + * @generated from field: string channel_id = 1; + */ + channelId: string; +}; + +/** + * Describes the message openshell.v1.RelayInit. + * Use `create(RelayInitSchema)` to create a new message. + */ +export const RelayInitSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 193); + +/** + * A single frame on the RelayStream RPC. + * + * The supervisor MUST send `init` as the first frame. All subsequent frames + * in either direction carry raw bytes in `data`. + * + * @generated from message openshell.v1.RelayFrame + */ +export type RelayFrame = Message<"openshell.v1.RelayFrame"> & { + /** + * @generated from oneof openshell.v1.RelayFrame.payload + */ + payload: { + /** + * @generated from field: openshell.v1.RelayInit init = 1; + */ + value: RelayInit; + case: "init"; + } | { + /** + * @generated from field: bytes data = 2; + */ + value: Uint8Array; + case: "data"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message openshell.v1.RelayFrame. + * Use `create(RelayFrameSchema)` to create a new message. + */ +export const RelayFrameSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 194); + +/** + * Initial frame for gateway peer relay forwarding. + * + * @generated from message openshell.v1.PeerRelayInit + */ +export type PeerRelayInit = Message<"openshell.v1.PeerRelayInit"> & { + /** + * Stable sandbox UUID whose supervisor relay should be opened. + * + * @generated from field: string sandbox_id = 1; + */ + sandboxId: string; + + /** + * Relay target to ask the owning gateway to open on its local supervisor + * session. The channel_id is assigned by the forwarding gateway. + * + * @generated from field: openshell.v1.RelayOpen relay_open = 2; + */ + relayOpen?: RelayOpen | undefined; + + /** + * Gateway replica id that initiated the peer relay. + * + * @generated from field: string requester_replica_id = 3; + */ + requesterReplicaId: string; +}; + +/** + * Describes the message openshell.v1.PeerRelayInit. + * Use `create(PeerRelayInitSchema)` to create a new message. + */ +export const PeerRelayInitSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 195); + +/** + * A single frame on the gateway-to-gateway peer relay RPC. + * + * @generated from message openshell.v1.PeerRelayFrame + */ +export type PeerRelayFrame = Message<"openshell.v1.PeerRelayFrame"> & { + /** + * @generated from oneof openshell.v1.PeerRelayFrame.payload + */ + payload: { + /** + * @generated from field: openshell.v1.PeerRelayInit init = 1; + */ + value: PeerRelayInit; + case: "init"; + } | { + /** + * @generated from field: bytes data = 2; + */ + value: Uint8Array; + case: "data"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message openshell.v1.PeerRelayFrame. + * Use `create(PeerRelayFrameSchema)` to create a new message. + */ +export const PeerRelayFrameSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 196); + +/** + * @generated from message openshell.v1.PeerConfigSandboxTarget + */ +export type PeerConfigSandboxTarget = Message<"openshell.v1.PeerConfigSandboxTarget"> & { + /** + * @generated from field: string sandbox_id = 1; + */ + sandboxId: string; + + /** + * Fences a targeted notification to the session observed by the sending replica. + * + * @generated from field: string session_id = 2; + */ + sessionId: string; +}; + +/** + * Describes the message openshell.v1.PeerConfigSandboxTarget. + * Use `create(PeerConfigSandboxTargetSchema)` to create a new message. + */ +export const PeerConfigSandboxTargetSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 197); + +/** + * Sandboxes in a workspace that attach the named provider. + * + * @generated from message openshell.v1.PeerConfigProviderTarget + */ +export type PeerConfigProviderTarget = Message<"openshell.v1.PeerConfigProviderTarget"> & { + /** + * @generated from field: string workspace = 1; + */ + workspace: string; + + /** + * @generated from field: string name = 2; + */ + name: string; +}; + +/** + * Describes the message openshell.v1.PeerConfigProviderTarget. + * Use `create(PeerConfigProviderTargetSchema)` to create a new message. + */ +export const PeerConfigProviderTargetSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 198); + +/** + * @generated from message openshell.v1.PeerNotifyConfigUpdateRequest + */ +export type PeerNotifyConfigUpdateRequest = Message<"openshell.v1.PeerNotifyConfigUpdateRequest"> & { + /** + * @generated from oneof openshell.v1.PeerNotifyConfigUpdateRequest.scope + */ + scope: { + /** + * @generated from field: openshell.v1.PeerConfigSandboxTarget sandbox = 1; + */ + value: PeerConfigSandboxTarget; + case: "sandbox"; + } | { + /** + * @generated from field: string workspace = 2; + */ + value: string; + case: "workspace"; + } | { + /** + * @generated from field: bool all_connected = 3; + */ + value: boolean; + case: "allConnected"; + } | { + /** + * @generated from field: openshell.v1.PeerConfigProviderTarget provider = 4; + */ + value: PeerConfigProviderTarget; + case: "provider"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message openshell.v1.PeerNotifyConfigUpdateRequest. + * Use `create(PeerNotifyConfigUpdateRequestSchema)` to create a new message. + */ +export const PeerNotifyConfigUpdateRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 199); + +/** + * @generated from message openshell.v1.PeerNotifyConfigUpdateResponse + */ +export type PeerNotifyConfigUpdateResponse = Message<"openshell.v1.PeerNotifyConfigUpdateResponse"> & { + /** + * The targeted session moved before the receiving replica accepted the notification. + * + * @generated from field: bool stale_owner = 1; + */ + staleOwner: boolean; +}; + +/** + * Describes the message openshell.v1.PeerNotifyConfigUpdateResponse. + * Use `create(PeerNotifyConfigUpdateResponseSchema)` to create a new message. + */ +export const PeerNotifyConfigUpdateResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 200); + +/** + * Supervisor reports the result of a relay open request. + * + * @generated from message openshell.v1.RelayOpenResult + */ +export type RelayOpenResult = Message<"openshell.v1.RelayOpenResult"> & { + /** + * Channel identifier from the RelayOpen request. + * + * @generated from field: string channel_id = 1; + */ + channelId: string; + + /** + * True if the relay was successfully established. + * + * @generated from field: bool success = 2; + */ + success: boolean; + + /** + * Error message if success is false. + * + * @generated from field: string error = 3; + */ + error: string; +}; + +/** + * Describes the message openshell.v1.RelayOpenResult. + * Use `create(RelayOpenResultSchema)` to create a new message. + */ +export const RelayOpenResultSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 201); + +/** + * Either side requests closure of a relay channel. + * + * @generated from message openshell.v1.RelayClose + */ +export type RelayClose = Message<"openshell.v1.RelayClose"> & { + /** + * Channel identifier to close. + * + * @generated from field: string channel_id = 1; + */ + channelId: string; + + /** + * Optional reason for closure. + * + * @generated from field: string reason = 2; + */ + reason: string; +}; + +/** + * Describes the message openshell.v1.RelayClose. + * Use `create(RelayCloseSchema)` to create a new message. + */ +export const RelayCloseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 202); + +/** + * Observed HTTP method+path pattern from L7 inspection. + * + * @generated from message openshell.v1.L7RequestSample + */ +export type L7RequestSample = Message<"openshell.v1.L7RequestSample"> & { + /** + * HTTP method: GET, POST, PUT, DELETE, etc. + * + * @generated from field: string method = 1; + */ + method: string; + + /** + * HTTP path: /v1/models, /repos/myorg/issues + * + * @generated from field: string path = 2; + */ + path: string; + + /** + * L7 decision: "audit" or "deny" (allowed requests not collected). + * + * @generated from field: string decision = 3; + */ + decision: string; + + /** + * Number of times this (method, path) was observed. + * + * @generated from field: uint32 count = 4; + */ + count: number; +}; + +/** + * Describes the message openshell.v1.L7RequestSample. + * Use `create(L7RequestSampleSchema)` to create a new message. + */ +export const L7RequestSampleSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 203); + +/** + * Structured denial summary from sandbox aggregator. + * + * @generated from message openshell.v1.DenialSummary + */ +export type DenialSummary = Message<"openshell.v1.DenialSummary"> & { + /** + * Sandbox ID that produced this summary. + * + * @generated from field: string sandbox_id = 1; + */ + sandboxId: string; + + /** + * Denied destination host. + * + * @generated from field: string host = 2; + */ + host: string; + + /** + * Denied destination port. + * + * @generated from field: uint32 port = 3; + */ + port: number; + + /** + * Binary that attempted the connection. + * + * @generated from field: string binary = 4; + */ + binary: string; + + /** + * Process ancestor chain. + * + * @generated from field: repeated string ancestors = 5; + */ + ancestors: string[]; + + /** + * Denial reason from OPA evaluation. + * + * @generated from field: string deny_reason = 6; + */ + denyReason: string; + + /** + * Time of the first denial. + * + * @generated from field: google.protobuf.Timestamp first_seen_time = 107; + */ + firstSeenTime?: Timestamp | undefined; + + /** + * Time of the most recent denial. + * + * @generated from field: google.protobuf.Timestamp last_seen_time = 108; + */ + lastSeenTime?: Timestamp | undefined; + + /** + * Number of denials in the current window. + * + * @generated from field: uint32 count = 9; + */ + count: number; + + /** + * Events dropped during aggregator cooldown. + * + * @generated from field: uint32 suppressed_count = 10; + */ + suppressedCount: number; + + /** + * Cumulative lifetime count (never resets). + * + * @generated from field: uint32 total_count = 11; + */ + totalCount: number; + + /** + * Distinct cmdline strings observed (sanitized of credentials). + * + * @generated from field: repeated string sample_cmdlines = 12; + */ + sampleCmdlines: string[]; + + /** + * SHA-256 of the binary for audit trail. + * + * @generated from field: string binary_sha256 = 13; + */ + binarySha256: string; + + /** + * True if emitted by stale-flush rather than threshold. + * + * @generated from field: bool persistent = 14; + */ + persistent: boolean; + + /** + * Denial category: "l4_deny", "l7_deny", "l7_audit", "ssrf". + * + * @generated from field: string denial_stage = 15; + */ + denialStage: string; + + /** + * Observed HTTP request patterns (from L7 inspection). + * + * @generated from field: repeated openshell.v1.L7RequestSample l7_request_samples = 16; + */ + l7RequestSamples: L7RequestSample[]; + + /** + * True if L7 inspection was active during observation window. + * + * @generated from field: bool l7_inspection_active = 17; + */ + l7InspectionActive: boolean; +}; + +/** + * Describes the message openshell.v1.DenialSummary. + * Use `create(DenialSummarySchema)` to create a new message. + */ +export const DenialSummarySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 204); + +/** + * Count of denied actions grouped only by sanitized telemetry category. + * + * @generated from message openshell.v1.DenialGroupCount + */ +export type DenialGroupCount = Message<"openshell.v1.DenialGroupCount"> & { + /** + * Sanitized denial category, e.g. "connect_policy", "l7_policy", "ssrf". + * + * @generated from field: string deny_group = 1; + */ + denyGroup: string; + + /** + * Number of denied actions in this category. + * + * @generated from field: uint32 denied_count = 2; + */ + deniedCount: number; +}; + +/** + * Describes the message openshell.v1.DenialGroupCount. + * Use `create(DenialGroupCountSchema)` to create a new message. + */ +export const DenialGroupCountSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 205); + +/** + * Anonymous sandbox network activity counters. This intentionally excludes + * hosts, paths, binaries, raw deny reasons, sandbox IDs, and user content. + * + * @generated from message openshell.v1.NetworkActivitySummary + */ +export type NetworkActivitySummary = Message<"openshell.v1.NetworkActivitySummary"> & { + /** + * Total observed network activities in the current window. + * + * @generated from field: uint32 network_activity_count = 1; + */ + networkActivityCount: number; + + /** + * Total denied actions in the current window. + * + * @generated from field: uint32 denied_action_count = 2; + */ + deniedActionCount: number; + + /** + * Denied action counts grouped by sanitized category. + * + * @generated from field: repeated openshell.v1.DenialGroupCount denials_by_group = 3; + */ + denialsByGroup: DenialGroupCount[]; +}; + +/** + * Describes the message openshell.v1.NetworkActivitySummary. + * Use `create(NetworkActivitySummarySchema)` to create a new message. + */ +export const NetworkActivitySummarySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 206); + +/** + * A proposed policy rule with rationale and approval status. + * + * @generated from message openshell.v1.PolicyChunk + */ +export type PolicyChunk = Message<"openshell.v1.PolicyChunk"> & { + /** + * Unique chunk identifier. + * + * @generated from field: string id = 1; + */ + id: string; + + /** + * Approval status: "pending", "approved", "rejected". + * + * @generated from field: string status = 2; + */ + status: string; + + /** + * Proposed network_policies map key. + * + * @generated from field: string rule_name = 3; + */ + ruleName: string; + + /** + * The proposed network policy rule. + * + * @generated from field: openshell.sandbox.v1.NetworkPolicyRule proposed_rule = 4; + */ + proposedRule?: NetworkPolicyRule | undefined; + + /** + * Human-readable explanation of why this rule is proposed. + * + * @generated from field: string rationale = 5; + */ + rationale: string; + + /** + * Security concerns flagged by analysis (empty if none). + * + * @generated from field: string security_notes = 6; + */ + securityNotes: string; + + /** + * Analysis confidence (0.0-1.0). 0 for mechanistic mode. + * + * @generated from field: float confidence = 7; + */ + confidence: number; + + /** + * IDs of denial summaries that led to this chunk. + * + * @generated from field: repeated string denial_summary_ids = 8; + */ + denialSummaryIds: string[]; + + /** + * Time when this chunk was created. + * + * @generated from field: google.protobuf.Timestamp created_time = 109; + */ + createdTime?: Timestamp | undefined; + + /** + * Time when the user approved or rejected the chunk. Absent if undecided. + * + * @generated from field: google.protobuf.Timestamp decided_time = 110; + */ + decidedTime?: Timestamp | undefined; + + /** + * Recommendation stage: "initial" or "refined" (progressive L7 visibility). + * + * @generated from field: string stage = 11; + */ + stage: string; + + /** + * For stage="refined": the initial chunk this replaces. + * + * @generated from field: string supersedes_chunk_id = 12; + */ + supersedesChunkId: string; + + /** + * How many times this endpoint has been seen across denial flush cycles. + * + * @generated from field: int32 hit_count = 13; + */ + hitCount: number; + + /** + * First time this endpoint was proposed. + * + * @generated from field: google.protobuf.Timestamp first_seen_time = 114; + */ + firstSeenTime?: Timestamp | undefined; + + /** + * Most recent time this endpoint was proposed again. + * + * @generated from field: google.protobuf.Timestamp last_seen_time = 115; + */ + lastSeenTime?: Timestamp | undefined; + + /** + * Binary path that triggered the denial (denormalized for display convenience). + * + * @generated from field: string binary = 16; + */ + binary: string; + + /** + * Validation verdict from gateway-side static checks (prover output). + * Free-form summary string for human consumption in the inbox card. + * Empty until the prover has run for this chunk. + * + * @generated from field: string validation_result = 17; + */ + validationResult: string; + + /** + * Operator-supplied free-form text accompanying a rejection. Populated + * when the reviewer rejects via `RejectDraftChunkRequest.reason`; surfaced + * back to the in-sandbox agent so it can revise the proposal. + * Empty for non-rejected chunks. + * + * @generated from field: string rejection_reason = 18; + */ + rejectionReason: string; + + /** + * Gateway-side merge/application preflight failure. Kept separate from + * prover output and operator rejection so clients can explain why a + * prover-clean proposal is not currently applicable. + * + * @generated from field: string application_error = 19; + */ + applicationError: string; + + /** + * Opaque digest binding review to the exact live inputs and complete + * effective candidate evaluated by the gateway. + * + * @generated from field: string review_token = 20; + */ + reviewToken: string; + + /** + * Deterministic hashes for compact candidate display and diagnostics. + * + * @generated from field: string current_effective_policy_hash = 21; + */ + currentEffectivePolicyHash: string; + + /** + * @generated from field: string candidate_effective_policy_hash = 22; + */ + candidateEffectivePolicyHash: string; + + /** + * Complete effective policies used for review. These contain policy + * configuration only; credential secret values are never materialized. + * + * @generated from field: openshell.sandbox.v1.SandboxPolicy current_effective_policy = 23; + */ + currentEffectivePolicy?: SandboxPolicy | undefined; + + /** + * @generated from field: openshell.sandbox.v1.SandboxPolicy candidate_effective_policy = 24; + */ + candidateEffectivePolicy?: SandboxPolicy | undefined; +}; + +/** + * Describes the message openshell.v1.PolicyChunk. + * Use `create(PolicyChunkSchema)` to create a new message. + */ +export const PolicyChunkSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 207); + +/** + * Notification that the draft policy was updated. + * + * @generated from message openshell.v1.DraftPolicyUpdate + */ +export type DraftPolicyUpdate = Message<"openshell.v1.DraftPolicyUpdate"> & { + /** + * Current draft version. + * + * @generated from field: uint64 draft_version = 1; + */ + draftVersion: bigint; + + /** + * Number of new chunks added in this update. + * + * @generated from field: uint32 new_chunks = 2; + */ + newChunks: number; + + /** + * Total pending chunks awaiting approval. + * + * @generated from field: uint32 total_pending = 3; + */ + totalPending: number; + + /** + * Brief description of what changed. + * + * @generated from field: string summary = 4; + */ + summary: string; +}; + +/** + * Describes the message openshell.v1.DraftPolicyUpdate. + * Use `create(DraftPolicyUpdateSchema)` to create a new message. + */ +export const DraftPolicyUpdateSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 208); + +/** + * Submit analysis results from sandbox to gateway. + * + * @generated from message openshell.v1.SubmitPolicyAnalysisRequest + */ +export type SubmitPolicyAnalysisRequest = Message<"openshell.v1.SubmitPolicyAnalysisRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 6; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * Aggregated denial summaries. + * + * @generated from field: repeated openshell.v1.DenialSummary summaries = 1; + */ + summaries: DenialSummary[]; + + /** + * Proposed policy chunks (validated by sandbox OPA engine). + * + * @generated from field: repeated openshell.v1.PolicyChunk proposed_chunks = 2; + */ + proposedChunks: PolicyChunk[]; + + /** + * Analysis mode. `mechanistic` is the observation-driven path from the + * denial aggregator — chunks targeting the same host|port|binary fold + * into one row with hit_count incremented. `agent_authored` is an + * intentional proposal from an in-sandbox agent — each submission lands + * as its own chunk so the redraft-after-rejection loop has a stable id + * to watch. Other values are treated as agent-style (no dedup) so a new + * mode does not silently collapse proposals. + * + * @generated from field: string analysis_mode = 3; + */ + analysisMode: string; + + /** + * Sandbox name. The authenticated sandbox principal remains authoritative + * for this internal callback. + * + * @generated from field: string name = 4; + */ + name: string; + + /** + * Anonymous network activity counters. + * + * @generated from field: repeated openshell.v1.NetworkActivitySummary network_activity_summaries = 5; + */ + networkActivitySummaries: NetworkActivitySummary[]; +}; + +/** + * Describes the message openshell.v1.SubmitPolicyAnalysisRequest. + * Use `create(SubmitPolicyAnalysisRequestSchema)` to create a new message. + */ +export const SubmitPolicyAnalysisRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 209); + +/** + * @generated from message openshell.v1.SubmitPolicyAnalysisResponse + */ +export type SubmitPolicyAnalysisResponse = Message<"openshell.v1.SubmitPolicyAnalysisResponse"> & { + /** + * Number of chunks accepted by the gateway. + * + * @generated from field: uint32 accepted_chunks = 1; + */ + acceptedChunks: number; + + /** + * Number of chunks rejected by gateway validation. + * + * @generated from field: uint32 rejected_chunks = 2; + */ + rejectedChunks: number; + + /** + * Reasons for each rejected chunk. + * + * @generated from field: repeated string rejection_reasons = 3; + */ + rejectionReasons: string[]; + + /** + * Server-assigned chunk IDs for the accepted chunks, in submission order. + * Agents use these to watch proposal state via policy.local's + * GET /v1/proposals/{id} and /wait endpoints. + * + * @generated from field: repeated string accepted_chunk_ids = 4; + */ + acceptedChunkIds: string[]; +}; + +/** + * Describes the message openshell.v1.SubmitPolicyAnalysisResponse. + * Use `create(SubmitPolicyAnalysisResponseSchema)` to create a new message. + */ +export const SubmitPolicyAnalysisResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 210); + +/** + * Get draft policy for a sandbox. + * + * @generated from message openshell.v1.GetDraftPolicyRequest + */ +export type GetDraftPolicyRequest = Message<"openshell.v1.GetDraftPolicyRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 3; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * Optional status filter: "pending", "approved", "rejected", or "" for all. + * + * @generated from field: string status_filter = 2; + */ + statusFilter: string; + + /** + * @generated from field: string sandbox = 1; + */ + sandbox: string; +}; + +/** + * Describes the message openshell.v1.GetDraftPolicyRequest. + * Use `create(GetDraftPolicyRequestSchema)` to create a new message. + */ +export const GetDraftPolicyRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 211); + +/** + * @generated from message openshell.v1.GetDraftPolicyResponse + */ +export type GetDraftPolicyResponse = Message<"openshell.v1.GetDraftPolicyResponse"> & { + /** + * Draft policy chunks. + * + * @generated from field: repeated openshell.v1.PolicyChunk chunks = 1; + */ + chunks: PolicyChunk[]; + + /** + * LLM-generated summary of all analysis (empty in mechanistic mode). + * + * @generated from field: string rolling_summary = 2; + */ + rollingSummary: string; + + /** + * Current draft version. + * + * @generated from field: uint64 draft_version = 3; + */ + draftVersion: bigint; + + /** + * Time when the last analysis completed. + * + * @generated from field: google.protobuf.Timestamp last_analyzed_time = 104; + */ + lastAnalyzedTime?: Timestamp | undefined; +}; + +/** + * Describes the message openshell.v1.GetDraftPolicyResponse. + * Use `create(GetDraftPolicyResponseSchema)` to create a new message. + */ +export const GetDraftPolicyResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 212); + +/** + * Approve a single draft chunk. + * + * @generated from message openshell.v1.ApproveDraftChunkRequest + */ +export type ApproveDraftChunkRequest = Message<"openshell.v1.ApproveDraftChunkRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 3; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * Chunk ID to approve. + * + * @generated from field: string chunk_id = 2; + */ + chunkId: string; + + /** + * Token returned with the reviewed PolicyChunk. Approval fails with + * FAILED_PRECONDITION if live decision inputs no longer match it. + * + * @generated from field: string review_token = 4; + */ + reviewToken: string; + + /** + * @generated from field: string sandbox = 1; + */ + sandbox: string; + + /** + * Optional nonzero UUID for durable at-most-once admission. Successful results + * can be replayed for 24 hours; see the API errors and retries reference. + * + * @generated from field: string request_id = 5; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.ApproveDraftChunkRequest. + * Use `create(ApproveDraftChunkRequestSchema)` to create a new message. + */ +export const ApproveDraftChunkRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 213); + +/** + * @generated from message openshell.v1.ApproveDraftChunkResponse + */ +export type ApproveDraftChunkResponse = Message<"openshell.v1.ApproveDraftChunkResponse"> & { + /** + * New policy version after merge. + * + * @generated from field: uint32 policy_version = 1; + */ + policyVersion: number; + + /** + * SHA-256 hash of the new policy. + * + * @generated from field: string policy_hash = 2; + */ + policyHash: string; +}; + +/** + * Describes the message openshell.v1.ApproveDraftChunkResponse. + * Use `create(ApproveDraftChunkResponseSchema)` to create a new message. + */ +export const ApproveDraftChunkResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 214); + +/** + * Reject a single draft chunk. + * + * @generated from message openshell.v1.RejectDraftChunkRequest + */ +export type RejectDraftChunkRequest = Message<"openshell.v1.RejectDraftChunkRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 4; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * Chunk ID to reject. + * + * @generated from field: string chunk_id = 2; + */ + chunkId: string; + + /** + * Optional reason for rejection (fed to LLM context in future analysis). + * + * @generated from field: string reason = 3; + */ + reason: string; + + /** + * @generated from field: string sandbox = 1; + */ + sandbox: string; + + /** + * Optional nonzero UUID for durable at-most-once admission. Successful results + * can be replayed for 24 hours; see the API errors and retries reference. + * + * @generated from field: string request_id = 5; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.RejectDraftChunkRequest. + * Use `create(RejectDraftChunkRequestSchema)` to create a new message. + */ +export const RejectDraftChunkRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 215); + +/** + * @generated from message openshell.v1.RejectDraftChunkResponse + */ +export type RejectDraftChunkResponse = Message<"openshell.v1.RejectDraftChunkResponse"> & { +}; + +/** + * Describes the message openshell.v1.RejectDraftChunkResponse. + * Use `create(RejectDraftChunkResponseSchema)` to create a new message. + */ +export const RejectDraftChunkResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 216); + +/** + * Approve all pending chunks. + * + * @generated from message openshell.v1.DraftChunkApproval + */ +export type DraftChunkApproval = Message<"openshell.v1.DraftChunkApproval"> & { + /** + * @generated from field: string chunk_id = 1; + */ + chunkId: string; + + /** + * @generated from field: string review_token = 2; + */ + reviewToken: string; +}; + +/** + * Describes the message openshell.v1.DraftChunkApproval. + * Use `create(DraftChunkApprovalSchema)` to create a new message. + */ +export const DraftChunkApprovalSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 217); + +/** + * @generated from message openshell.v1.ApproveAllDraftChunksRequest + */ +export type ApproveAllDraftChunksRequest = Message<"openshell.v1.ApproveAllDraftChunksRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 4; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * Include chunks with security_notes (default false: skips them). + * + * @generated from field: bool include_security_flagged = 2; + */ + includeSecurityFlagged: boolean; + + /** + * Exact reviewed chunks and tokens. The server validates them against one + * live snapshot, stages compatible operations in order, and writes once. + * + * @generated from field: repeated openshell.v1.DraftChunkApproval approvals = 3; + */ + approvals: DraftChunkApproval[]; + + /** + * @generated from field: string sandbox = 1; + */ + sandbox: string; + + /** + * Optional nonzero UUID for durable at-most-once admission. Successful results + * can be replayed for 24 hours; see the API errors and retries reference. + * + * @generated from field: string request_id = 5; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.ApproveAllDraftChunksRequest. + * Use `create(ApproveAllDraftChunksRequestSchema)` to create a new message. + */ +export const ApproveAllDraftChunksRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 218); + +/** + * @generated from message openshell.v1.ApproveAllDraftChunksResponse + */ +export type ApproveAllDraftChunksResponse = Message<"openshell.v1.ApproveAllDraftChunksResponse"> & { + /** + * New policy version after merge. + * + * @generated from field: uint32 policy_version = 1; + */ + policyVersion: number; + + /** + * SHA-256 hash of the new policy. + * + * @generated from field: string policy_hash = 2; + */ + policyHash: string; + + /** + * Number of chunks approved. + * + * @generated from field: uint32 chunks_approved = 3; + */ + chunksApproved: number; + + /** + * Number of chunks skipped for any reason, including security flags, + * stale or invalid candidates, and conflicts within the staged batch. + * + * @generated from field: uint32 chunks_skipped = 4; + */ + chunksSkipped: number; +}; + +/** + * Describes the message openshell.v1.ApproveAllDraftChunksResponse. + * Use `create(ApproveAllDraftChunksResponseSchema)` to create a new message. + */ +export const ApproveAllDraftChunksResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 219); + +/** + * Edit a pending chunk in-place. + * + * @generated from message openshell.v1.EditDraftChunkRequest + */ +export type EditDraftChunkRequest = Message<"openshell.v1.EditDraftChunkRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 4; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * Chunk ID to edit. + * + * @generated from field: string chunk_id = 2; + */ + chunkId: string; + + /** + * The modified rule (replaces existing proposed_rule). + * + * @generated from field: openshell.sandbox.v1.NetworkPolicyRule proposed_rule = 3; + */ + proposedRule?: NetworkPolicyRule | undefined; + + /** + * @generated from field: string sandbox = 1; + */ + sandbox: string; + + /** + * Optional nonzero UUID for durable at-most-once admission. Successful results + * can be replayed for 24 hours; see the API errors and retries reference. + * + * @generated from field: string request_id = 5; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.EditDraftChunkRequest. + * Use `create(EditDraftChunkRequestSchema)` to create a new message. + */ +export const EditDraftChunkRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 220); + +/** + * @generated from message openshell.v1.EditDraftChunkResponse + */ +export type EditDraftChunkResponse = Message<"openshell.v1.EditDraftChunkResponse"> & { +}; + +/** + * Describes the message openshell.v1.EditDraftChunkResponse. + * Use `create(EditDraftChunkResponseSchema)` to create a new message. + */ +export const EditDraftChunkResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 221); + +/** + * Reverse an approval (remove merged rule from active policy). + * + * @generated from message openshell.v1.UndoDraftChunkRequest + */ +export type UndoDraftChunkRequest = Message<"openshell.v1.UndoDraftChunkRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 3; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * Chunk ID to undo. + * + * @generated from field: string chunk_id = 2; + */ + chunkId: string; + + /** + * @generated from field: string sandbox = 1; + */ + sandbox: string; + + /** + * Optional nonzero UUID for durable at-most-once admission. Successful results + * can be replayed for 24 hours; see the API errors and retries reference. + * + * @generated from field: string request_id = 4; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.UndoDraftChunkRequest. + * Use `create(UndoDraftChunkRequestSchema)` to create a new message. + */ +export const UndoDraftChunkRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 222); + +/** + * @generated from message openshell.v1.UndoDraftChunkResponse + */ +export type UndoDraftChunkResponse = Message<"openshell.v1.UndoDraftChunkResponse"> & { + /** + * New policy version after removal. + * + * @generated from field: uint32 policy_version = 1; + */ + policyVersion: number; + + /** + * SHA-256 hash of the updated policy. + * + * @generated from field: string policy_hash = 2; + */ + policyHash: string; +}; + +/** + * Describes the message openshell.v1.UndoDraftChunkResponse. + * Use `create(UndoDraftChunkResponseSchema)` to create a new message. + */ +export const UndoDraftChunkResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 223); + +/** + * Clear all pending draft chunks for a sandbox. + * + * @generated from message openshell.v1.ClearDraftChunksRequest + */ +export type ClearDraftChunksRequest = Message<"openshell.v1.ClearDraftChunksRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 2; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: string sandbox = 1; + */ + sandbox: string; + + /** + * Optional nonzero UUID for durable at-most-once admission. Successful results + * can be replayed for 24 hours; see the API errors and retries reference. + * + * @generated from field: string request_id = 3; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.ClearDraftChunksRequest. + * Use `create(ClearDraftChunksRequestSchema)` to create a new message. + */ +export const ClearDraftChunksRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 224); + +/** + * @generated from message openshell.v1.ClearDraftChunksResponse + */ +export type ClearDraftChunksResponse = Message<"openshell.v1.ClearDraftChunksResponse"> & { + /** + * Number of chunks cleared. + * + * @generated from field: uint32 chunks_cleared = 1; + */ + chunksCleared: number; +}; + +/** + * Describes the message openshell.v1.ClearDraftChunksResponse. + * Use `create(ClearDraftChunksResponseSchema)` to create a new message. + */ +export const ClearDraftChunksResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 225); + +/** + * Get decision history for a sandbox's draft policy. + * + * @generated from message openshell.v1.GetDraftHistoryRequest + */ +export type GetDraftHistoryRequest = Message<"openshell.v1.GetDraftHistoryRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 2; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: string sandbox = 1; + */ + sandbox: string; +}; + +/** + * Describes the message openshell.v1.GetDraftHistoryRequest. + * Use `create(GetDraftHistoryRequestSchema)` to create a new message. + */ +export const GetDraftHistoryRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 226); + +/** + * @generated from message openshell.v1.DraftHistoryEntry + */ +export type DraftHistoryEntry = Message<"openshell.v1.DraftHistoryEntry"> & { + /** + * Time when the event occurred. + * + * @generated from field: google.protobuf.Timestamp event_time = 101; + */ + eventTime?: Timestamp | undefined; + + /** + * Event type: "denial_detected", "analysis_cycle", "approved", + * "rejected", "edited", "undone", "cleared". + * + * @generated from field: string event_type = 2; + */ + eventType: string; + + /** + * Human-readable description. + * + * @generated from field: string description = 3; + */ + description: string; + + /** + * Associated chunk ID (if applicable). + * + * @generated from field: string chunk_id = 4; + */ + chunkId: string; +}; + +/** + * Describes the message openshell.v1.DraftHistoryEntry. + * Use `create(DraftHistoryEntrySchema)` to create a new message. + */ +export const DraftHistoryEntrySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 227); + +/** + * @generated from message openshell.v1.GetDraftHistoryResponse + */ +export type GetDraftHistoryResponse = Message<"openshell.v1.GetDraftHistoryResponse"> & { + /** + * Chronological decision history. + * + * @generated from field: repeated openshell.v1.DraftHistoryEntry entries = 1; + */ + entries: DraftHistoryEntry[]; +}; + +/** + * Describes the message openshell.v1.GetDraftHistoryResponse. + * Use `create(GetDraftHistoryResponseSchema)` to create a new message. + */ +export const GetDraftHistoryResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 228); + +/** + * Create workspace request. + * + * @generated from message openshell.v1.CreateWorkspaceRequest + */ +export type CreateWorkspaceRequest = Message<"openshell.v1.CreateWorkspaceRequest"> & { + /** + * Workspace name. Must be a valid DNS-1123 label. + * + * @generated from field: string name = 1; + */ + name: string; + + /** + * Optional labels for the workspace (key-value metadata). + * + * @generated from field: map labels = 2; + */ + labels: { [key: string]: string }; + + /** + * Optional nonzero UUID. Same ID and payload replay success for 24 hours. + * + * @generated from field: string request_id = 3; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.CreateWorkspaceRequest. + * Use `create(CreateWorkspaceRequestSchema)` to create a new message. + */ +export const CreateWorkspaceRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 229); + +/** + * Create workspace response. + * + * @generated from message openshell.v1.CreateWorkspaceResponse + */ +export type CreateWorkspaceResponse = Message<"openshell.v1.CreateWorkspaceResponse"> & { + /** + * @generated from field: openshell.datamodel.v1.Workspace workspace = 1; + */ + workspace?: Workspace | undefined; +}; + +/** + * Describes the message openshell.v1.CreateWorkspaceResponse. + * Use `create(CreateWorkspaceResponseSchema)` to create a new message. + */ +export const CreateWorkspaceResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 230); + +/** + * Get workspace request. + * + * @generated from message openshell.v1.GetWorkspaceRequest + */ +export type GetWorkspaceRequest = Message<"openshell.v1.GetWorkspaceRequest"> & { + /** + * Workspace name (canonical lookup key). + * + * @generated from field: string name = 1; + */ + name: string; +}; + +/** + * Describes the message openshell.v1.GetWorkspaceRequest. + * Use `create(GetWorkspaceRequestSchema)` to create a new message. + */ +export const GetWorkspaceRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 231); + +/** + * Get workspace response. + * + * @generated from message openshell.v1.GetWorkspaceResponse + */ +export type GetWorkspaceResponse = Message<"openshell.v1.GetWorkspaceResponse"> & { + /** + * @generated from field: openshell.datamodel.v1.Workspace workspace = 1; + */ + workspace?: Workspace | undefined; +}; + +/** + * Describes the message openshell.v1.GetWorkspaceResponse. + * Use `create(GetWorkspaceResponseSchema)` to create a new message. + */ +export const GetWorkspaceResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 232); + +/** + * List workspaces request. + * + * @generated from message openshell.v1.ListWorkspacesRequest + */ +export type ListWorkspacesRequest = Message<"openshell.v1.ListWorkspacesRequest"> & { + /** + * The maximum number of workspaces to return. Zero uses 100. Values above + * 1000 are coerced to 1000; negative values are invalid. + * + * @generated from field: int32 page_size = 1; + */ + pageSize: number; + + /** + * Token from a previous ListWorkspaces response. All other request parameters + * except page_size must match the request that produced it. + * + * @generated from field: string page_token = 2; + */ + pageToken: string; + + /** + * Optional label selector for filtering (format: "key1=value1,key2=value2"). + * + * @generated from field: string label_selector = 3; + */ + labelSelector: string; +}; + +/** + * Describes the message openshell.v1.ListWorkspacesRequest. + * Use `create(ListWorkspacesRequestSchema)` to create a new message. + */ +export const ListWorkspacesRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 233); + +/** + * List workspaces response. + * + * @generated from message openshell.v1.ListWorkspacesResponse + */ +export type ListWorkspacesResponse = Message<"openshell.v1.ListWorkspacesResponse"> & { + /** + * @generated from field: repeated openshell.datamodel.v1.Workspace workspaces = 1; + */ + workspaces: Workspace[]; + + /** + * Token for the next page. Empty when there are no subsequent pages. + * + * @generated from field: string next_page_token = 2; + */ + nextPageToken: string; +}; + +/** + * Describes the message openshell.v1.ListWorkspacesResponse. + * Use `create(ListWorkspacesResponseSchema)` to create a new message. + */ +export const ListWorkspacesResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 234); + +/** + * Delete workspace request. + * + * @generated from message openshell.v1.DeleteWorkspaceRequest + */ +export type DeleteWorkspaceRequest = Message<"openshell.v1.DeleteWorkspaceRequest"> & { + /** + * Workspace name (canonical lookup key). + * + * @generated from field: string name = 1; + */ + name: string; + + /** + * @generated from field: bool allow_missing = 2; + */ + allowMissing: boolean; + + /** + * Optional nonzero UUID. Same ID and payload replay success for 24 hours. + * + * @generated from field: string request_id = 3; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.DeleteWorkspaceRequest. + * Use `create(DeleteWorkspaceRequestSchema)` to create a new message. + */ +export const DeleteWorkspaceRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 235); + +/** + * Delete workspace response. + * + * @generated from message openshell.v1.DeleteWorkspaceResponse + */ +export type DeleteWorkspaceResponse = Message<"openshell.v1.DeleteWorkspaceResponse"> & { + /** + * @generated from field: openshell.v1.DeletionOutcome outcome = 2; + */ + outcome: DeletionOutcome; +}; + +/** + * Describes the message openshell.v1.DeleteWorkspaceResponse. + * Use `create(DeleteWorkspaceResponseSchema)` to create a new message. + */ +export const DeleteWorkspaceResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 236); + +/** + * Workspace membership record. + * + * @generated from message openshell.v1.WorkspaceMember + */ +export type WorkspaceMember = Message<"openshell.v1.WorkspaceMember"> & { + /** + * @generated from field: openshell.datamodel.v1.ObjectMeta metadata = 1; + */ + metadata?: ObjectMeta | undefined; + + /** + * OIDC subject claim identifying the principal. + * + * @generated from field: string principal_subject = 2; + */ + principalSubject: string; + + /** + * Role assigned to the principal within the workspace. + * + * @generated from field: openshell.v1.WorkspaceRole role = 3; + */ + role: WorkspaceRole; +}; + +/** + * Describes the message openshell.v1.WorkspaceMember. + * Use `create(WorkspaceMemberSchema)` to create a new message. + */ +export const WorkspaceMemberSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 237); + +/** + * Add workspace member request. + * + * @generated from message openshell.v1.AddWorkspaceMemberRequest + */ +export type AddWorkspaceMemberRequest = Message<"openshell.v1.AddWorkspaceMemberRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 1; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * OIDC subject claim identifying the principal. + * + * @generated from field: string principal_subject = 2; + */ + principalSubject: string; + + /** + * Role to assign. + * + * @generated from field: openshell.v1.WorkspaceRole role = 3; + */ + role: WorkspaceRole; + + /** + * Optional nonzero UUID. Same ID and payload replay success for 24 hours. + * + * @generated from field: string request_id = 4; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.AddWorkspaceMemberRequest. + * Use `create(AddWorkspaceMemberRequestSchema)` to create a new message. + */ +export const AddWorkspaceMemberRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 238); + +/** + * Add workspace member response. + * + * @generated from message openshell.v1.AddWorkspaceMemberResponse + */ +export type AddWorkspaceMemberResponse = Message<"openshell.v1.AddWorkspaceMemberResponse"> & { + /** + * @generated from field: openshell.v1.WorkspaceMember member = 1; + */ + member?: WorkspaceMember | undefined; +}; + +/** + * Describes the message openshell.v1.AddWorkspaceMemberResponse. + * Use `create(AddWorkspaceMemberResponseSchema)` to create a new message. + */ +export const AddWorkspaceMemberResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 239); + +/** + * Remove workspace member request. + * + * @generated from message openshell.v1.RemoveWorkspaceMemberRequest + */ +export type RemoveWorkspaceMemberRequest = Message<"openshell.v1.RemoveWorkspaceMemberRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 1; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * OIDC subject claim identifying the principal to remove. + * + * @generated from field: string principal_subject = 2; + */ + principalSubject: string; + + /** + * @generated from field: bool allow_missing = 3; + */ + allowMissing: boolean; + + /** + * Optional nonzero UUID. Same ID and payload replay success for 24 hours. + * + * @generated from field: string request_id = 4; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.RemoveWorkspaceMemberRequest. + * Use `create(RemoveWorkspaceMemberRequestSchema)` to create a new message. + */ +export const RemoveWorkspaceMemberRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 240); + +/** + * Remove workspace member response. + * + * @generated from message openshell.v1.RemoveWorkspaceMemberResponse + */ +export type RemoveWorkspaceMemberResponse = Message<"openshell.v1.RemoveWorkspaceMemberResponse"> & { + /** + * @generated from field: openshell.v1.DeletionOutcome outcome = 2; + */ + outcome: DeletionOutcome; +}; + +/** + * Describes the message openshell.v1.RemoveWorkspaceMemberResponse. + * Use `create(RemoveWorkspaceMemberResponseSchema)` to create a new message. + */ +export const RemoveWorkspaceMemberResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 241); + +/** + * List workspace members request. + * + * @generated from message openshell.v1.ListWorkspaceMembersRequest + */ +export type ListWorkspaceMembersRequest = Message<"openshell.v1.ListWorkspaceMembersRequest"> & { + /** + * Workspace scope. Only a named workspace selection is accepted. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 1; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * The maximum number of members to return. Zero uses 100. Values above + * 1000 are coerced to 1000; negative values are invalid. + * + * @generated from field: int32 page_size = 2; + */ + pageSize: number; + + /** + * Token from a previous ListWorkspaceMembers response. All other request + * parameters except page_size must match the request that produced it. + * + * @generated from field: string page_token = 3; + */ + pageToken: string; +}; + +/** + * Describes the message openshell.v1.ListWorkspaceMembersRequest. + * Use `create(ListWorkspaceMembersRequestSchema)` to create a new message. + */ +export const ListWorkspaceMembersRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 242); + +/** + * List workspace members response. + * + * @generated from message openshell.v1.ListWorkspaceMembersResponse + */ +export type ListWorkspaceMembersResponse = Message<"openshell.v1.ListWorkspaceMembersResponse"> & { + /** + * @generated from field: repeated openshell.v1.WorkspaceMember members = 1; + */ + members: WorkspaceMember[]; + + /** + * Token for the next page. Empty when there are no subsequent pages. + * + * @generated from field: string next_page_token = 2; + */ + nextPageToken: string; +}; + +/** + * Describes the message openshell.v1.ListWorkspaceMembersResponse. + * Use `create(ListWorkspaceMembersResponseSchema)` to create a new message. + */ +export const ListWorkspaceMembersResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 243); + +/** + * Short-lived credential for one policy-authorized extension service. + * Kept at the end of the file so adding it does not renumber existing + * generated message descriptors. + * + * @generated from message openshell.v1.ExtensionServiceCredential + */ +export type ExtensionServiceCredential = Message<"openshell.v1.ExtensionServiceCredential"> & { + /** + * Operator registration name used to correlate the credential with the + * stable service registration delivered by GetSandboxConfig. + * + * @generated from field: string service_name = 1; + */ + serviceName: string; + + /** + * Gateway-minted JWT with an audience derived from the registration. + * + * @generated from field: string token = 2; + */ + token: string; + + /** + * Absolute expiry of the token. + * + * @generated from field: google.protobuf.Timestamp expiration_time = 103; + */ + expirationTime?: Timestamp | undefined; +}; + +/** + * Describes the message openshell.v1.ExtensionServiceCredential. + * Use `create(ExtensionServiceCredentialSchema)` to create a new message. + */ +export const ExtensionServiceCredentialSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 244); + +/** + * One redacted endpoint result in a supervisor's complete status report. + * + * @generated from message openshell.v1.EndpointObservation + */ +export type EndpointObservation = Message<"openshell.v1.EndpointObservation"> & { + /** + * Stable identifier derived from the configured host, ports, and path. + * + * @generated from field: string endpoint_id = 1; + */ + endpointId: string; + + /** + * Latest result under the reported configuration and supervisor session. + * + * @generated from field: openshell.v1.EndpointResult result = 2; + */ + result: EndpointResult; + + /** + * Bounded cause of result, when the supervisor classified it. Each failure + * domain names the results it can explain. + * + * @generated from field: openshell.v1.EndpointFailure failure = 3; + */ + failure?: EndpointFailure | undefined; +}; + +/** + * Describes the message openshell.v1.EndpointObservation. + * Use `create(EndpointObservationSchema)` to create a new message. + */ +export const EndpointObservationSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 245); + +/** + * Complete endpoint status report for the caller's current configuration. + * + * @generated from message openshell.v1.ReportEndpointStatusRequest + */ +export type ReportEndpointStatusRequest = Message<"openshell.v1.ReportEndpointStatusRequest"> & { + /** + * Sandbox id. Must match the authenticated sandbox principal. + * + * @generated from field: string sandbox_id = 1; + */ + sandboxId: string; + + /** + * Hash from the active effective policy delivered by the gateway. + * + * @generated from field: string policy_hash = 2; + */ + policyHash: string; + + /** + * Provider environment revision delivered with the active configuration. + * + * @generated from field: uint64 provider_env_revision = 3; + */ + providerEnvRevision: bigint; + + /** + * Exactly one result for every distinct observed endpoint in the policy. + * + * @generated from field: repeated openshell.v1.EndpointObservation observations = 4; + */ + observations: EndpointObservation[]; + + /** + * Endpoints with a new observation in this batch. Omitted endpoints retain + * their prior report time; an identical retry never advances report time. + * + * @generated from field: repeated string observed_endpoint_ids = 5; + */ + observedEndpointIds: string[]; + + /** + * Active ConnectSupervisor session that owns these observations. + * + * @generated from field: string supervisor_session_id = 6; + */ + supervisorSessionId: string; + + /** + * Monotonically increasing sequence within the authenticated session. Gaps + * are allowed when an inventory reset supersedes a frozen snapshot. Retrying + * a report preserves its complete body and sequence for idempotent acknowledgement. + * + * @generated from field: uint64 report_sequence = 7; + */ + reportSequence: bigint; + + /** + * Complete latest grant state. Omission retains legacy compatibility; + * a present message with no last_failure explicitly clears the prior cause. + * + * @generated from field: openshell.v1.TokenGrantStatus token_grant_status = 8; + */ + tokenGrantStatus?: TokenGrantStatus | undefined; +}; + +/** + * Describes the message openshell.v1.ReportEndpointStatusRequest. + * Use `create(ReportEndpointStatusRequestSchema)` to create a new message. + */ +export const ReportEndpointStatusRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 246); + +/** + * Latest token-grant state sent by the authenticated supervisor. + * + * @generated from message openshell.v1.TokenGrantStatus + */ +export type TokenGrantStatus = Message<"openshell.v1.TokenGrantStatus"> & { + /** + * @generated from field: openshell.v1.TokenGrantFailureObservation last_failure = 1; + */ + lastFailure?: TokenGrantFailureObservation | undefined; +}; + +/** + * Describes the message openshell.v1.TokenGrantStatus. + * Use `create(TokenGrantStatusSchema)` to create a new message. + */ +export const TokenGrantStatusSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 247); + +/** + * A refused grant and its destination, without request paths or remote text. + * This describes the failed attempt, not the destination's current health. + * + * @generated from message openshell.v1.TokenGrantFailureObservation + */ +export type TokenGrantFailureObservation = Message<"openshell.v1.TokenGrantFailureObservation"> & { + /** + * Canonical observed host or IP address, bounded to 253 ASCII bytes. + * + * @generated from field: string destination_host = 1; + */ + destinationHost: string; + + /** + * Observed destination port in the range 1 through 65535. + * + * @generated from field: uint32 destination_port = 2; + */ + destinationPort: number; + + /** + * Bounded token_grant cause. Provider and credential may be absent when + * selection failed; the request ID still identifies the refused exchange. + * + * @generated from field: openshell.v1.EndpointFailure failure = 3; + */ + failure?: EndpointFailure | undefined; +}; + +/** + * Describes the message openshell.v1.TokenGrantFailureObservation. + * Use `create(TokenGrantFailureObservationSchema)` to create a new message. + */ +export const TokenGrantFailureObservationSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 248); + +/** + * Empty acknowledgement for a persisted endpoint status report. + * + * @generated from message openshell.v1.ReportEndpointStatusResponse + */ +export type ReportEndpointStatusResponse = Message<"openshell.v1.ReportEndpointStatusResponse"> & { +}; + +/** + * Describes the message openshell.v1.ReportEndpointStatusResponse. + * Use `create(ReportEndpointStatusResponseSchema)` to create a new message. + */ +export const ReportEndpointStatusResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 249); + +/** + * A configured endpoint and its last accepted network result in one record. + * Address fields contain policy selectors, never request URLs or credentials. + * + * @generated from message openshell.v1.EndpointStatus + */ +export type EndpointStatus = Message<"openshell.v1.EndpointStatus"> & { + /** + * Stable identifier for selecting this endpoint without parsing display text. + * + * @generated from field: string endpoint_id = 1; + */ + endpointId: string; + + /** + * Lowercase configured endpoint host. + * + * @generated from field: string host = 2; + */ + host: string; + + /** + * Sorted, deduplicated effective endpoint ports. Validated endpoints have at + * least one port. + * + * @generated from field: repeated uint32 ports = 3; + */ + ports: number[]; + + /** + * Canonical configured path selector; an unrestricted path is /**. + * + * @generated from field: string path = 4; + */ + path: string; + + /** + * Last accepted result, aggregated across configured callers and ports. + * NoObservedExchange retains the address and has no report timestamp. + * + * @generated from field: openshell.v1.EndpointResult last_result = 5; + */ + lastResult: EndpointResult; + + /** + * Time when the gateway accepted the observation. This is not the request + * time: still-valid evidence can be reaccepted after a reset. Identical + * same-sequence retries do not advance it. Absent until a result is reported. + * + * @generated from field: google.protobuf.Timestamp last_reported_time = 106; + */ + lastReportedTime?: Timestamp | undefined; + + /** + * Bounded cause of last_result, when the supervisor classified it. Each + * failure domain names the results it can explain. Replaced or cleared by + * every later observation, and cleared by the same resets that clear + * last_result. + * + * @generated from field: openshell.v1.EndpointFailure last_failure = 7; + */ + lastFailure?: EndpointFailure | undefined; +}; + +/** + * Describes the message openshell.v1.EndpointStatus. + * Use `create(EndpointStatusSchema)` to create a new message. + */ +export const EndpointStatusSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 250); + +/** + * Durable provisioning attempt, independent of supervisor registration and polling. + * + * @generated from message openshell.v1.SandboxProvisioning + */ +export type SandboxProvisioning = Message<"openshell.v1.SandboxProvisioning"> & { + /** + * @generated from field: string attempt_id = 1; + */ + attemptId: string; + + /** + * @generated from field: string configuration_change_id = 2; + */ + configurationChangeId: string; + + /** + * @generated from field: google.protobuf.Timestamp configuration_change_time = 3; + */ + configurationChangeTime?: Timestamp | undefined; + + /** + * @generated from field: google.protobuf.Timestamp first_rejection_time = 4; + */ + firstRejectionTime?: Timestamp | undefined; + + /** + * Active preparation or admission-repair deadline. Absent after Ready/timeout. + * + * @generated from field: google.protobuf.Timestamp deadline = 5; + */ + deadline?: Timestamp | undefined; + + /** + * @generated from field: google.protobuf.Timestamp timeout_time = 6; + */ + timeoutTime?: Timestamp | undefined; + + /** + * Set only after both supervisor and workload compute have been reclaimed. + * + * @generated from field: google.protobuf.Timestamp cleanup_completed_time = 7; + */ + cleanupCompletedTime?: Timestamp | undefined; + + /** + * A safe gateway-authored diagnostic; never a raw driver error. + * + * @generated from field: string cleanup_error = 8; + */ + cleanupError: string; + + /** + * Durable backoff for interrupted or failed reclamation. + * + * @generated from field: google.protobuf.Timestamp cleanup_retry_time = 9; + */ + cleanupRetryTime?: Timestamp | undefined; + + /** + * Attachment edits have their own durable clock; status writes do not change it. + * + * @generated from field: string attachment_change_id = 10; + */ + attachmentChangeId: string; + + /** + * @generated from field: google.protobuf.Timestamp attachment_change_time = 11; + */ + attachmentChangeTime?: Timestamp | undefined; + + /** + * Absolute ceiling for image preparation and initial supervisor startup. + * Set once per new attempt; progress, configuration writes, and restarts + * cannot extend it. Absent on attempts created before preparation timing. + * + * @generated from field: google.protobuf.Timestamp preparation_deadline = 12; + */ + preparationDeadline?: Timestamp | undefined; + + /** + * First authenticated supervisor configuration report for this attempt. + * Starts the admission repair window. Absent while preparing, including + * after a preparation timeout. Duplicate reports never change this value. + * + * @generated from field: google.protobuf.Timestamp admission_start_time = 13; + */ + admissionStartTime?: Timestamp | undefined; + + /** + * An owned driver create/start future is still pending. Claimed before + * dispatch and cleared on its actual success or error response. Monitor + * interruption, owner loss, and StopSandbox/NotFound do not clear it. + * While set, cleanup cannot complete and retry/deletion remain blocked. + * This does not strengthen a driver's transport-error settlement contract. + * + * @generated from field: bool driver_operation_pending = 14; + */ + driverOperationPending: boolean; + + /** + * Unique for each claimed driver operation, including recovery and automatic + * restart. Retained after settlement to reject delayed callbacks from an + * earlier operation on the same attempt and runtime generation. + * + * @generated from field: string driver_operation_id = 15; + */ + driverOperationId: string; +}; + +/** + * Describes the message openshell.v1.SandboxProvisioning. + * Use `create(SandboxProvisioningSchema)` to create a new message. + */ +export const SandboxProvisioningSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 251); + +/** + * Create-time request to expose one loopback HTTP service in a sandbox. + * + * @generated from message openshell.v1.SandboxServiceExposure + */ +export type SandboxServiceExposure = Message<"openshell.v1.SandboxServiceExposure"> & { + /** + * Service name within the sandbox. Empty selects the unnamed endpoint. + * + * @generated from field: string service = 1; + */ + service: string; + + /** + * Loopback TCP port inside the sandbox. + * + * @generated from field: uint32 target_port = 2; + */ + targetPort: number; + + /** + * Application authorization behavior. Omission resolves to STRIP. + * + * @generated from field: openshell.v1.ServiceAuthorizationMode authorization_mode = 3; + */ + authorizationMode: ServiceAuthorizationMode; +}; + +/** + * Describes the message openshell.v1.SandboxServiceExposure. + * Use `create(SandboxServiceExposureSchema)` to create a new message. + */ +export const SandboxServiceExposureSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 252); + +/** + * Bounded cause of a failed endpoint observation, including failures before + * any request reaches the endpoint. No field carries remote + * text: code and stage come from the domain's closed sets, provider and + * credential_key are configured names, and request_id is an opaque random ID. + * + * @generated from message openshell.v1.EndpointFailure + */ +export type EndpointFailure = Message<"openshell.v1.EndpointFailure"> & { + /** + * @generated from field: openshell.v1.EndpointFailureDomain domain = 1; + */ + domain: EndpointFailureDomain; + + /** + * Stable lower_snake_case code from the domain's closed set, such as + * provider_authorization_required. + * + * @generated from field: string code = 2; + */ + code: string; + + /** + * Who can resolve the failure; always the action documented for the code. + * + * @generated from field: openshell.v1.ProviderCredentialRefreshRecoveryAction recovery_action = 3; + */ + recoveryAction: ProviderCredentialRefreshRecoveryAction; + + /** + * Provider whose credential failed. Empty when the failure happened before + * a credential was selected. + * + * @generated from field: string provider = 4; + */ + provider: string; + + /** + * Credential name within the provider. Never a credential value. + * + * @generated from field: string credential_key = 5; + */ + credentialKey: string; + + /** + * Step that observed the failure, from the domain's closed set. + * + * @generated from field: string stage = 6; + */ + stage: string; + + /** + * HTTP status a token service returned, when one was received. + * + * @generated from field: optional uint32 upstream_http_status = 7; + */ + upstreamHttpStatus?: number | undefined; + + /** + * Supervisor-minted UUID of the refused exchange. The workload receives the + * same value in the x-openshell-request-id response header. + * + * @generated from field: string request_id = 8; + */ + requestId: string; +}; + +/** + * Describes the message openshell.v1.EndpointFailure. + * Use `create(EndpointFailureSchema)` to create a new message. + */ +export const EndpointFailureSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 253); + +/** + * Gateway lease challenge on an authenticated sandbox supervisor session. + * Expiry is measured from gateway issuance, never report receipt. + * + * @generated from message openshell.v1.ServiceRouteLease + */ +export type ServiceRouteLease = Message<"openshell.v1.ServiceRouteLease"> & { + /** + * @generated from field: uint64 sequence = 1; + */ + sequence: bigint; + + /** + * @generated from field: google.protobuf.Duration duration = 2; + */ + duration?: Duration | undefined; + + /** + * Absolute deadline prevents a queued challenge extending serving authority + * after takeover. Hosts cap this by duration and require synchronized clocks. + * + * @generated from field: google.protobuf.Timestamp expires_at = 3; + */ + expiresAt?: Timestamp | undefined; +}; + +/** + * Describes the message openshell.v1.ServiceRouteLease. + * Use `create(ServiceRouteLeaseSchema)` to create a new message. + */ +export const ServiceRouteLeaseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 254); + +/** + * Complete installed-route replacement for a live lease challenge. The + * supervisor reports only if its remaining serving freshness covers duration. + * No address is accepted from the supervisor; the compute driver supplies it. + * + * @generated from message openshell.v1.SupervisorServiceAdvertisement + */ +export type SupervisorServiceAdvertisement = Message<"openshell.v1.SupervisorServiceAdvertisement"> & { + /** + * @generated from field: uint64 lease_sequence = 1; + */ + leaseSequence: bigint; + + /** + * @generated from field: string configuration_instance_id = 2; + */ + configurationInstanceId: string; + + /** + * @generated from field: uint64 config_revision = 3; + */ + configRevision: bigint; + + /** + * @generated from field: repeated openshell.sandbox.v1.SandboxServiceRoute routes = 4; + */ + routes: SandboxServiceRoute[]; + + /** + * Domain actually installed by the process listener, not the gateway URL. + * + * @generated from field: string service_domain = 5; + */ + serviceDomain: string; +}; + +/** + * Describes the message openshell.v1.SupervisorServiceAdvertisement. + * Use `create(SupervisorServiceAdvertisementSchema)` to create a new message. + */ +export const SupervisorServiceAdvertisementSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 255); + +/** + * @generated from enum openshell.v1.ExtensionKind + */ +export enum ExtensionKind { + /** + * @generated from enum value: EXTENSION_KIND_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: EXTENSION_KIND_COMPUTE_DRIVER = 1; + */ + COMPUTE_DRIVER = 1, + + /** + * @generated from enum value: EXTENSION_KIND_CREDENTIAL_DRIVER = 2; + */ + CREDENTIAL_DRIVER = 2, + + /** + * @generated from enum value: EXTENSION_KIND_GATEWAY_INTERCEPTOR = 3; + */ + GATEWAY_INTERCEPTOR = 3, + + /** + * @generated from enum value: EXTENSION_KIND_SUPERVISOR_MIDDLEWARE = 4; + */ + SUPERVISOR_MIDDLEWARE = 4, +} + +/** + * Describes the enum openshell.v1.ExtensionKind. + */ +export const ExtensionKindSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_openshell, 0); + +/** + * High-level sandbox lifecycle phase derived by the gateway. + * + * Clients should rely on this normalized lifecycle summary for readiness and + * deletion decisions instead of interpreting raw conditions. + * + * @generated from enum openshell.v1.SandboxPhase + */ +export enum SandboxPhase { + /** + * @generated from enum value: SANDBOX_PHASE_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: SANDBOX_PHASE_PROVISIONING = 1; + */ + PROVISIONING = 1, + + /** + * @generated from enum value: SANDBOX_PHASE_READY = 2; + */ + READY = 2, + + /** + * @generated from enum value: SANDBOX_PHASE_ERROR = 3; + */ + ERROR = 3, + + /** + * @generated from enum value: SANDBOX_PHASE_DELETING = 4; + */ + DELETING = 4, + + /** + * @generated from enum value: SANDBOX_PHASE_UNKNOWN = 5; + */ + UNKNOWN = 5, + + /** + * @generated from enum value: SANDBOX_PHASE_STOPPING = 6; + */ + STOPPING = 6, + + /** + * @generated from enum value: SANDBOX_PHASE_STOPPED = 7; + */ + STOPPED = 7, + + /** + * @generated from enum value: SANDBOX_PHASE_STARTING = 8; + */ + STARTING = 8, + + /** + * The canonical main process exited successfully and its result is final. + * + * @generated from enum value: SANDBOX_PHASE_COMPLETED = 9; + */ + COMPLETED = 9, + + /** + * The gateway requested suspension and the driver has not confirmed it. + * + * @generated from enum value: SANDBOX_PHASE_SUSPENDING = 11; + */ + SUSPENDING = 11, + + /** + * The workload is frozen and its memory state is retained by the isolation + * backend. ResumeSandbox restores it; StartSandbox discards it. + * + * @generated from enum value: SANDBOX_PHASE_SUSPENDED = 12; + */ + SUSPENDED = 12, +} + +/** + * Describes the enum openshell.v1.SandboxPhase. + */ +export const SandboxPhaseSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_openshell, 1); + +/** + * Operation whose installed authority is tracked by a receipt. + * + * @generated from enum openshell.v1.ProviderMutationKind + */ +export enum ProviderMutationKind { + /** + * @generated from enum value: PROVIDER_MUTATION_KIND_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: PROVIDER_MUTATION_KIND_ATTACH = 1; + */ + ATTACH = 1, + + /** + * @generated from enum value: PROVIDER_MUTATION_KIND_DETACH = 2; + */ + DETACH = 2, + + /** + * @generated from enum value: PROVIDER_MUTATION_KIND_UPDATE = 3; + */ + UPDATE = 3, + + /** + * Reconstructed status for existing desired state without a mutation receipt. + * + * @generated from enum value: PROVIDER_MUTATION_KIND_OBSERVE = 4; + */ + OBSERVE = 4, +} + +/** + * Describes the enum openshell.v1.ProviderMutationKind. + */ +export const ProviderMutationKindSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_openshell, 2); + +/** + * Readiness states describe persisted intent separately from installed state. + * + * @generated from enum openshell.v1.ProviderReadinessState + */ +export enum ProviderReadinessState { + /** + * @generated from enum value: PROVIDER_READINESS_STATE_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: PROVIDER_READINESS_STATE_PERSISTED = 1; + */ + PERSISTED = 1, + + /** + * @generated from enum value: PROVIDER_READINESS_STATE_PENDING = 2; + */ + PENDING = 2, + + /** + * @generated from enum value: PROVIDER_READINESS_STATE_READY = 3; + */ + READY = 3, + + /** + * @generated from enum value: PROVIDER_READINESS_STATE_WITHHELD = 4; + */ + WITHHELD = 4, + + /** + * @generated from enum value: PROVIDER_READINESS_STATE_REVOKED = 5; + */ + REVOKED = 5, + + /** + * @generated from enum value: PROVIDER_READINESS_STATE_FAILED = 6; + */ + FAILED = 6, + + /** + * @generated from enum value: PROVIDER_READINESS_STATE_SUPERSEDED = 7; + */ + SUPERSEDED = 7, +} + +/** + * Describes the enum openshell.v1.ProviderReadinessState. + */ +export const ProviderReadinessStateSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_openshell, 3); + +/** + * Closed reason categories are safe to display. Raw installation errors are + * never part of the readiness protocol. + * + * @generated from enum openshell.v1.ProviderReadinessReason + */ +export enum ProviderReadinessReason { + /** + * @generated from enum value: PROVIDER_READINESS_REASON_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: PROVIDER_READINESS_REASON_WAITING_FOR_SUPERVISOR = 1; + */ + WAITING_FOR_SUPERVISOR = 1, + + /** + * @generated from enum value: PROVIDER_READINESS_REASON_WAITING_FOR_CREDENTIALS = 2; + */ + WAITING_FOR_CREDENTIALS = 2, + + /** + * @generated from enum value: PROVIDER_READINESS_REASON_WAITING_FOR_POLICY = 3; + */ + WAITING_FOR_POLICY = 3, + + /** + * @generated from enum value: PROVIDER_READINESS_REASON_WAITING_FOR_PROCESS = 4; + */ + WAITING_FOR_PROCESS = 4, + + /** + * @generated from enum value: PROVIDER_READINESS_REASON_UNSUPPORTED_SUPERVISOR = 5; + */ + UNSUPPORTED_SUPERVISOR = 5, + + /** + * @generated from enum value: PROVIDER_READINESS_REASON_CREDENTIALS_WITHHELD = 6; + */ + CREDENTIALS_WITHHELD = 6, + + /** + * @generated from enum value: PROVIDER_READINESS_REASON_CREDENTIAL_INSTALL_FAILED = 7; + */ + CREDENTIAL_INSTALL_FAILED = 7, + + /** + * @generated from enum value: PROVIDER_READINESS_REASON_POLICY_ACTIVATION_FAILED = 8; + */ + POLICY_ACTIVATION_FAILED = 8, + + /** + * @generated from enum value: PROVIDER_READINESS_REASON_PROCESS_INSTALL_FAILED = 9; + */ + PROCESS_INSTALL_FAILED = 9, + + /** + * @generated from enum value: PROVIDER_READINESS_REASON_SUPERVISOR_DISCONNECTED = 10; + */ + SUPERVISOR_DISCONNECTED = 10, + + /** + * @generated from enum value: PROVIDER_READINESS_REASON_SUPERVISOR_LEASE_EXPIRED = 11; + */ + SUPERVISOR_LEASE_EXPIRED = 11, + + /** + * @generated from enum value: PROVIDER_READINESS_REASON_DESIRED_STATE_CHANGED = 12; + */ + DESIRED_STATE_CHANGED = 12, + + /** + * @generated from enum value: PROVIDER_READINESS_REASON_CREDENTIAL_EXPIRED = 13; + */ + CREDENTIAL_EXPIRED = 13, + + /** + * @generated from enum value: PROVIDER_READINESS_REASON_LOCAL_POLICY = 14; + */ + LOCAL_POLICY = 14, + + /** + * @generated from enum value: PROVIDER_READINESS_REASON_SNAPSHOT_MISMATCH = 15; + */ + SNAPSHOT_MISMATCH = 15, +} + +/** + * Describes the enum openshell.v1.ProviderReadinessReason. + */ +export const ProviderReadinessReasonSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_openshell, 4); + +/** + * Component whose desired state is tracked by a durable update operation. + * + * @generated from enum openshell.v1.ConfigComponent + */ +export enum ConfigComponent { + /** + * @generated from enum value: CONFIG_COMPONENT_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: CONFIG_COMPONENT_SANDBOX_CONFIG = 1; + */ + SANDBOX_CONFIG = 1, + + /** + * @generated from enum value: CONFIG_COMPONENT_PROVIDER_ENVIRONMENT = 2; + */ + PROVIDER_ENVIRONMENT = 2, +} + +/** + * Describes the enum openshell.v1.ConfigComponent. + */ +export const ConfigComponentSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_openshell, 5); + +/** + * Result of applying a component revision at its owning runtime boundary. + * + * @generated from enum openshell.v1.ConfigApplyOutcome + */ +export enum ConfigApplyOutcome { + /** + * @generated from enum value: CONFIG_APPLY_OUTCOME_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: CONFIG_APPLY_OUTCOME_APPLIED = 1; + */ + APPLIED = 1, + + /** + * @generated from enum value: CONFIG_APPLY_OUTCOME_IGNORED_DUPLICATE = 2; + */ + IGNORED_DUPLICATE = 2, + + /** + * @generated from enum value: CONFIG_APPLY_OUTCOME_IGNORED_STALE = 3; + */ + IGNORED_STALE = 3, + + /** + * @generated from enum value: CONFIG_APPLY_OUTCOME_RETAINED_LOCAL_OVERRIDE = 4; + */ + RETAINED_LOCAL_OVERRIDE = 4, + + /** + * @generated from enum value: CONFIG_APPLY_OUTCOME_DEGRADED = 5; + */ + DEGRADED = 5, + + /** + * @generated from enum value: CONFIG_APPLY_OUTCOME_FAILED_RETAINED_LAST_KNOWN_GOOD = 6; + */ + FAILED_RETAINED_LAST_KNOWN_GOOD = 6, + + /** + * @generated from enum value: CONFIG_APPLY_OUTCOME_FAILED_CLOSED = 7; + */ + FAILED_CLOSED = 7, + + /** + * @generated from enum value: CONFIG_APPLY_OUTCOME_UNSUPPORTED = 8; + */ + UNSUPPORTED = 8, +} + +/** + * Describes the enum openshell.v1.ConfigApplyOutcome. + */ +export const ConfigApplyOutcomeSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_openshell, 6); + +/** + * Durable lifecycle of one desired-state update operation. + * + * @generated from enum openshell.v1.ConfigUpdateOperationState + */ +export enum ConfigUpdateOperationState { + /** + * @generated from enum value: CONFIG_UPDATE_OPERATION_STATE_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: CONFIG_UPDATE_OPERATION_STATE_PENDING = 1; + */ + PENDING = 1, + + /** + * @generated from enum value: CONFIG_UPDATE_OPERATION_STATE_APPLIED = 2; + */ + APPLIED = 2, + + /** + * @generated from enum value: CONFIG_UPDATE_OPERATION_STATE_INACTIVE = 3; + */ + INACTIVE = 3, + + /** + * @generated from enum value: CONFIG_UPDATE_OPERATION_STATE_FAILED = 4; + */ + FAILED = 4, + + /** + * @generated from enum value: CONFIG_UPDATE_OPERATION_STATE_SUPERSEDED = 5; + */ + SUPERSEDED = 5, + + /** + * @generated from enum value: CONFIG_UPDATE_OPERATION_STATE_CANCELLED = 6; + */ + CANCELLED = 6, +} + +/** + * Describes the enum openshell.v1.ConfigUpdateOperationState. + */ +export const ConfigUpdateOperationStateSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_openshell, 7); + +/** + * Provider credential token grant configuration. + * When present, the credential is obtained dynamically via OAuth2 grant when needed. + * + * @generated from enum openshell.v1.ProviderCredentialTokenGrantType + */ +export enum ProviderCredentialTokenGrantType { + /** + * @generated from enum value: PROVIDER_CREDENTIAL_TOKEN_GRANT_TYPE_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: PROVIDER_CREDENTIAL_TOKEN_GRANT_TYPE_CLIENT_CREDENTIALS = 1; + */ + CLIENT_CREDENTIALS = 1, + + /** + * @generated from enum value: PROVIDER_CREDENTIAL_TOKEN_GRANT_TYPE_TOKEN_EXCHANGE = 2; + */ + TOKEN_EXCHANGE = 2, +} + +/** + * Describes the enum openshell.v1.ProviderCredentialTokenGrantType. + */ +export const ProviderCredentialTokenGrantTypeSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_openshell, 8); + +/** + * @generated from enum openshell.v1.ProviderCredentialRefreshStrategy + */ +export enum ProviderCredentialRefreshStrategy { + /** + * @generated from enum value: PROVIDER_CREDENTIAL_REFRESH_STRATEGY_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: PROVIDER_CREDENTIAL_REFRESH_STRATEGY_STATIC = 1; + */ + STATIC = 1, + + /** + * @generated from enum value: PROVIDER_CREDENTIAL_REFRESH_STRATEGY_EXTERNAL = 2; + */ + EXTERNAL = 2, + + /** + * @generated from enum value: PROVIDER_CREDENTIAL_REFRESH_STRATEGY_OAUTH2_REFRESH_TOKEN = 3; + */ + OAUTH2_REFRESH_TOKEN = 3, + + /** + * @generated from enum value: PROVIDER_CREDENTIAL_REFRESH_STRATEGY_OAUTH2_CLIENT_CREDENTIALS = 4; + */ + OAUTH2_CLIENT_CREDENTIALS = 4, + + /** + * @generated from enum value: PROVIDER_CREDENTIAL_REFRESH_STRATEGY_GOOGLE_SERVICE_ACCOUNT_JWT = 5; + */ + GOOGLE_SERVICE_ACCOUNT_JWT = 5, + + /** + * @generated from enum value: PROVIDER_CREDENTIAL_REFRESH_STRATEGY_AWS_STS_ASSUME_ROLE = 6; + */ + AWS_STS_ASSUME_ROLE = 6, +} + +/** + * Describes the enum openshell.v1.ProviderCredentialRefreshStrategy. + */ +export const ProviderCredentialRefreshStrategySchema: GenEnum = /*@__PURE__*/ + enumDesc(file_openshell, 9); + +/** + * Stable provider profile categories used by clients for grouping and filtering. + * + * @generated from enum openshell.v1.ProviderProfileCategory + */ +export enum ProviderProfileCategory { + /** + * @generated from enum value: PROVIDER_PROFILE_CATEGORY_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: PROVIDER_PROFILE_CATEGORY_OTHER = 1; + */ + OTHER = 1, + + /** + * @generated from enum value: PROVIDER_PROFILE_CATEGORY_INFERENCE = 2; + */ + INFERENCE = 2, + + /** + * @generated from enum value: PROVIDER_PROFILE_CATEGORY_AGENT = 3; + */ + AGENT = 3, + + /** + * @generated from enum value: PROVIDER_PROFILE_CATEGORY_SOURCE_CONTROL = 4; + */ + SOURCE_CONTROL = 4, + + /** + * @generated from enum value: PROVIDER_PROFILE_CATEGORY_MESSAGING = 5; + */ + MESSAGING = 5, + + /** + * @generated from enum value: PROVIDER_PROFILE_CATEGORY_DATA = 6; + */ + DATA = 6, + + /** + * @generated from enum value: PROVIDER_PROFILE_CATEGORY_KNOWLEDGE = 7; + */ + KNOWLEDGE = 7, +} + +/** + * Describes the enum openshell.v1.ProviderProfileCategory. + */ +export const ProviderProfileCategorySchema: GenEnum = /*@__PURE__*/ + enumDesc(file_openshell, 10); + +/** + * Receivers treat UNSPECIFIED and unknown values as secret. + * + * @generated from enum openshell.v1.ProviderEnvironmentValueClassification + */ +export enum ProviderEnvironmentValueClassification { + /** + * @generated from enum value: PROVIDER_ENVIRONMENT_VALUE_CLASSIFICATION_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: PROVIDER_ENVIRONMENT_VALUE_CLASSIFICATION_NON_SECRET = 1; + */ + NON_SECRET = 1, + + /** + * @generated from enum value: PROVIDER_ENVIRONMENT_VALUE_CLASSIFICATION_STATIC_CREDENTIAL = 2; + */ + STATIC_CREDENTIAL = 2, +} + +/** + * Describes the enum openshell.v1.ProviderEnvironmentValueClassification. + */ +export const ProviderEnvironmentValueClassificationSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_openshell, 11); + +/** + * @generated from enum openshell.v1.ConfigurationAdmissionState + */ +export enum ConfigurationAdmissionState { + /** + * @generated from enum value: CONFIGURATION_ADMISSION_STATE_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: CONFIGURATION_ADMISSION_STATE_PENDING = 1; + */ + PENDING = 1, + + /** + * @generated from enum value: CONFIGURATION_ADMISSION_STATE_ACCEPTED = 2; + */ + ACCEPTED = 2, + + /** + * @generated from enum value: CONFIGURATION_ADMISSION_STATE_REJECTED = 3; + */ + REJECTED = 3, +} + +/** + * Describes the enum openshell.v1.ConfigurationAdmissionState. + */ +export const ConfigurationAdmissionStateSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_openshell, 12); + +/** + * Policy load status. + * + * @generated from enum openshell.v1.PolicyStatus + */ +export enum PolicyStatus { + /** + * @generated from enum value: POLICY_STATUS_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * Server received the update; sandbox has not yet loaded it. + * + * @generated from enum value: POLICY_STATUS_PENDING = 1; + */ + PENDING = 1, + + /** + * Sandbox successfully applied this policy version. + * + * @generated from enum value: POLICY_STATUS_LOADED = 2; + */ + LOADED = 2, + + /** + * Sandbox attempted to apply but failed; LKG policy remains active. + * ListSandboxPolicies also uses FAILED for historical payloads that are + * invalid under the current schema; load_error contains the diagnostic. + * + * @generated from enum value: POLICY_STATUS_FAILED = 3; + */ + FAILED = 3, + + /** + * A newer version was persisted before the sandbox loaded this one. + * + * @generated from enum value: POLICY_STATUS_SUPERSEDED = 4; + */ + SUPERSEDED = 4, +} + +/** + * Describes the enum openshell.v1.PolicyStatus. + */ +export const PolicyStatusSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_openshell, 13); + +/** + * Service status enum. + * + * @generated from enum openshell.v1.ServiceStatus + */ +export enum ServiceStatus { + /** + * @generated from enum value: SERVICE_STATUS_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: SERVICE_STATUS_HEALTHY = 1; + */ + HEALTHY = 1, + + /** + * @generated from enum value: SERVICE_STATUS_DEGRADED = 2; + */ + DEGRADED = 2, + + /** + * @generated from enum value: SERVICE_STATUS_UNHEALTHY = 3; + */ + UNHEALTHY = 3, +} + +/** + * Describes the enum openshell.v1.ServiceStatus. + */ +export const ServiceStatusSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_openshell, 14); + +/** + * Workspace-scoped role for members. + * + * @generated from enum openshell.v1.WorkspaceRole + */ +export enum WorkspaceRole { + /** + * @generated from enum value: WORKSPACE_ROLE_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: WORKSPACE_ROLE_USER = 1; + */ + USER = 1, + + /** + * @generated from enum value: WORKSPACE_ROLE_ADMIN = 2; + */ + ADMIN = 2, +} + +/** + * Describes the enum openshell.v1.WorkspaceRole. + */ +export const WorkspaceRoleSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_openshell, 15); + +/** + * Stable recovery action for the most recent provider credential refresh + * failure. Kept after the pre-existing enums so adding it does not renumber + * their generated descriptors. Clients should use this field instead of + * parsing last_error. + * + * @generated from enum openshell.v1.ProviderCredentialRefreshRecoveryAction + */ +export enum ProviderCredentialRefreshRecoveryAction { + /** + * @generated from enum value: PROVIDER_CREDENTIAL_REFRESH_RECOVERY_ACTION_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: PROVIDER_CREDENTIAL_REFRESH_RECOVERY_ACTION_RETRY = 1; + */ + RETRY = 1, + + /** + * @generated from enum value: PROVIDER_CREDENTIAL_REFRESH_RECOVERY_ACTION_REAUTHORIZE = 2; + */ + REAUTHORIZE = 2, + + /** + * @generated from enum value: PROVIDER_CREDENTIAL_REFRESH_RECOVERY_ACTION_FIX_CONFIGURATION = 3; + */ + FIX_CONFIGURATION = 3, + + /** + * @generated from enum value: PROVIDER_CREDENTIAL_REFRESH_RECOVERY_ACTION_INVESTIGATE = 4; + */ + INVESTIGATE = 4, +} + +/** + * Describes the enum openshell.v1.ProviderCredentialRefreshRecoveryAction. + */ +export const ProviderCredentialRefreshRecoveryActionSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_openshell, 16); + +/** + * Policy applied when the canonical main process exits outside an intentional + * stop or delete operation. Kept after existing enums so generated enum + * descriptors remain stable. + * + * @generated from enum openshell.v1.SandboxRestartPolicy + */ +export enum SandboxRestartPolicy { + /** + * @generated from enum value: SANDBOX_RESTART_POLICY_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: SANDBOX_RESTART_POLICY_NEVER = 1; + */ + NEVER = 1, + + /** + * @generated from enum value: SANDBOX_RESTART_POLICY_ON_FAILURE = 2; + */ + ON_FAILURE = 2, + + /** + * @generated from enum value: SANDBOX_RESTART_POLICY_ALWAYS = 3; + */ + ALWAYS = 3, +} + +/** + * Describes the enum openshell.v1.SandboxRestartPolicy. + */ +export const SandboxRestartPolicySchema: GenEnum = /*@__PURE__*/ + enumDesc(file_openshell, 17); + +/** + * Result of a public delete, membership removal, or session revocation. + * Default requests return NOT_FOUND for a missing target. With allow_missing, + * only a missing target becomes ALREADY_ABSENT; parent lookup, authorization, + * validation, precondition, and backend errors retain their normal status. + * These results describe the targeted resource, not a same-name replacement. + * + * @generated from enum openshell.v1.DeletionOutcome + */ +export enum DeletionOutcome { + /** + * No outcome was supplied. Never infer completion from this value. + * + * @generated from enum value: DELETION_OUTCOME_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * The targeted gateway resource is removed (or the SSH session is revoked). + * Downstream platform garbage collection may still be finishing. + * + * @generated from enum value: DELETION_OUTCOME_COMPLETED = 1; + */ + COMPLETED = 1, + + /** + * Sandbox deletion is accepted but its gateway record still exists. + * Observe the targeted sandbox ID until it disappears for completion. + * + * @generated from enum value: DELETION_OUTCOME_ACCEPTED = 2; + */ + ACCEPTED = 2, + + /** + * The target did not exist and allow_missing was true. + * + * @generated from enum value: DELETION_OUTCOME_ALREADY_ABSENT = 3; + */ + ALREADY_ABSENT = 3, +} + +/** + * Describes the enum openshell.v1.DeletionOutcome. + */ +export const DeletionOutcomeSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_openshell, 18); + +/** + * Last observed network result for a configured external tool endpoint. + * Results describe accepted traffic observations, not present availability. + * + * @generated from enum openshell.v1.EndpointResult + */ +export enum EndpointResult { + /** + * @generated from enum value: ENDPOINT_RESULT_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * No exchange has been observed under the current configuration and session. + * + * @generated from enum value: ENDPOINT_RESULT_NO_OBSERVED_EXCHANGE = 1; + */ + NO_OBSERVED_EXCHANGE = 1, + + /** + * An upstream HTTP status below 400 was received. Its body can still contain + * an MCP error; this result does not establish tool-call success. + * + * @generated from enum value: ENDPOINT_RESULT_HTTP_RESPONSE_RECEIVED = 2; + */ + HTTP_RESPONSE_RECEIVED = 2, + + /** + * OpenShell policy denied the request locally. + * + * @generated from enum value: ENDPOINT_RESULT_POLICY_DENIED = 3; + */ + POLICY_DENIED = 3, + + /** + * An applicable OpenShell-managed credential was unavailable. + * + * @generated from enum value: ENDPOINT_RESULT_CREDENTIAL_UNAVAILABLE = 4; + */ + CREDENTIAL_UNAVAILABLE = 4, + + /** + * TLS setup for the upstream connection failed. + * + * @generated from enum value: ENDPOINT_RESULT_TLS_FAILED = 5; + */ + TLS_FAILED = 5, + + /** + * The upstream transport failed before an HTTP response arrived. + * + * @generated from enum value: ENDPOINT_RESULT_TRANSPORT_FAILED = 6; + */ + TRANSPORT_FAILED = 6, + + /** + * The upstream service returned an HTTP rejection. + * + * @generated from enum value: ENDPOINT_RESULT_UPSTREAM_REJECTED = 7; + */ + UPSTREAM_REJECTED = 7, +} + +/** + * Describes the enum openshell.v1.EndpointResult. + */ +export const EndpointResultSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_openshell, 19); + +/** + * Controls whether an exposed service receives the request's application + * Authorization header. + * + * @generated from enum openshell.v1.ServiceAuthorizationMode + */ +export enum ServiceAuthorizationMode { + /** + * Omission preserves the secure legacy behavior and resolves to STRIP. + * + * @generated from enum value: SERVICE_AUTHORIZATION_MODE_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * Remove Authorization before forwarding to the sandbox service. + * + * @generated from enum value: SERVICE_AUTHORIZATION_MODE_STRIP = 1; + */ + STRIP = 1, + + /** + * Forward one syntactically valid bearer Authorization header unchanged. + * + * @generated from enum value: SERVICE_AUTHORIZATION_MODE_BEARER_PASSTHROUGH = 2; + */ + BEARER_PASSTHROUGH = 2, +} + +/** + * Describes the enum openshell.v1.ServiceAuthorizationMode. + */ +export const ServiceAuthorizationModeSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_openshell, 20); + +/** + * Subsystem whose closed code set explains an endpoint failure. Each domain + * defines its codes, stages, recovery actions, and the endpoint results it + * can explain. Kept at the end of the file so adding it does not renumber + * existing generated descriptors. + * + * @generated from enum openshell.v1.EndpointFailureDomain + */ +export enum EndpointFailureDomain { + /** + * @generated from enum value: ENDPOINT_FAILURE_DOMAIN_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * A dynamic token grant for a provider credential failed, so OpenShell + * refused the request before any of it reached the endpoint. Explains + * ENDPOINT_RESULT_CREDENTIAL_UNAVAILABLE. + * + * @generated from enum value: ENDPOINT_FAILURE_DOMAIN_TOKEN_GRANT = 1; + */ + TOKEN_GRANT = 1, +} + +/** + * Describes the enum openshell.v1.EndpointFailureDomain. + */ +export const EndpointFailureDomainSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_openshell, 21); + +/** + * OpenShell service provides sandbox, provider, and runtime management capabilities. + * + * Conventions: + * - This file owns the public API resource model exposed to OpenShell clients. + * - `Sandbox`, `SandboxSpec`, `SandboxStatus`, and `SandboxPhase` are gateway-owned + * public types. Internal compute drivers must not import or return them directly. + * - The gateway translates internal compute-driver observations into these public + * resource messages before persisting or returning them to clients. + * + * @generated from service openshell.v1.OpenShell + */ +export const OpenShell: GenService<{ + /** + * Check the health of the service. + * + * @generated from rpc openshell.v1.OpenShell.Health + */ + health: { + methodKind: "unary"; + input: typeof HealthRequestSchema; + output: typeof HealthResponseSchema; + }, + /** + * Return the authenticated caller identity established by the gateway. + * + * @generated from rpc openshell.v1.OpenShell.GetCurrentUser + */ + getCurrentUser: { + methodKind: "unary"; + input: typeof GetCurrentUserRequestSchema; + output: typeof GetCurrentUserResponseSchema; + }, + /** + * Fetch elevated live gateway runtime metadata. + * + * @generated from rpc openshell.v1.OpenShell.GetGatewayInfo + */ + getGatewayInfo: { + methodKind: "unary"; + input: typeof GetGatewayInfoRequestSchema; + output: typeof GetGatewayInfoResponseSchema; + }, + /** + * Create a new sandbox. + * + * @generated from rpc openshell.v1.OpenShell.CreateSandbox + */ + createSandbox: { + methodKind: "unary"; + input: typeof CreateSandboxRequestSchema; + output: typeof SandboxResponseSchema; + }, + /** + * Allocate a gateway-owned staging slot for a local rootfs tar archive. + * + * The gateway creates a request-scoped directory inside the compute driver's + * staging root and returns an opaque single-use token plus the absolute path + * the client must write the archive to. The token is then passed as + * `template.driver_config..rootfs_tar_staging_token` on + * CreateSandbox; callers never name a filesystem path themselves. Only a + * client sharing the gateway's filesystem can complete the upload. + * + * @generated from rpc openshell.v1.OpenShell.BeginRootfsTarStaging + */ + beginRootfsTarStaging: { + methodKind: "unary"; + input: typeof BeginRootfsTarStagingRequestSchema; + output: typeof BeginRootfsTarStagingResponseSchema; + }, + /** + * Fetch a sandbox by name. + * + * @generated from rpc openshell.v1.OpenShell.GetSandbox + */ + getSandbox: { + methodKind: "unary"; + input: typeof GetSandboxRequestSchema; + output: typeof SandboxResponseSchema; + }, + /** + * List sandboxes. + * + * @generated from rpc openshell.v1.OpenShell.ListSandboxes + */ + listSandboxes: { + methodKind: "unary"; + input: typeof ListSandboxesRequestSchema; + output: typeof ListSandboxesResponseSchema; + }, + /** + * Create a reusable sandbox workload template. + * + * @generated from rpc openshell.v1.OpenShell.CreateSandboxTemplate + */ + createSandboxTemplate: { + methodKind: "unary"; + input: typeof CreateSandboxTemplateRequestSchema; + output: typeof SandboxTemplateResponseSchema; + }, + /** + * Fetch a reusable sandbox workload template by name. + * + * @generated from rpc openshell.v1.OpenShell.GetSandboxTemplate + */ + getSandboxTemplate: { + methodKind: "unary"; + input: typeof GetSandboxTemplateRequestSchema; + output: typeof SandboxTemplateResponseSchema; + }, + /** + * List reusable sandbox workload templates. + * + * @generated from rpc openshell.v1.OpenShell.ListSandboxTemplates + */ + listSandboxTemplates: { + methodKind: "unary"; + input: typeof ListSandboxTemplatesRequestSchema; + output: typeof ListSandboxTemplatesResponseSchema; + }, + /** + * Delete a reusable sandbox workload template by name. + * + * @generated from rpc openshell.v1.OpenShell.DeleteSandboxTemplate + */ + deleteSandboxTemplate: { + methodKind: "unary"; + input: typeof DeleteSandboxTemplateRequestSchema; + output: typeof DeleteSandboxTemplateResponseSchema; + }, + /** + * List provider records attached to a sandbox. + * + * @generated from rpc openshell.v1.OpenShell.ListSandboxProviders + */ + listSandboxProviders: { + methodKind: "unary"; + input: typeof ListSandboxProvidersRequestSchema; + output: typeof ListSandboxProvidersResponseSchema; + }, + /** + * Attach a provider record to an existing sandbox. + * + * @generated from rpc openshell.v1.OpenShell.AttachSandboxProvider + */ + attachSandboxProvider: { + methodKind: "unary"; + input: typeof AttachSandboxProviderRequestSchema; + output: typeof AttachSandboxProviderResponseSchema; + }, + /** + * Detach a provider record from an existing sandbox. + * + * @generated from rpc openshell.v1.OpenShell.DetachSandboxProvider + */ + detachSandboxProvider: { + methodKind: "unary"; + input: typeof DetachSandboxProviderRequestSchema; + output: typeof DetachSandboxProviderResponseSchema; + }, + /** + * Inspect the installed authority for one sandbox provider mutation. + * + * @generated from rpc openshell.v1.OpenShell.GetSandboxProviderStatus + */ + getSandboxProviderStatus: { + methodKind: "unary"; + input: typeof GetSandboxProviderStatusRequestSchema; + output: typeof GetSandboxProviderStatusResponseSchema; + }, + /** + * Delete a sandbox by name. + * + * @generated from rpc openshell.v1.OpenShell.DeleteSandbox + */ + deleteSandbox: { + methodKind: "unary"; + input: typeof DeleteSandboxRequestSchema; + output: typeof DeleteSandboxResponseSchema; + }, + /** + * Stop a sandbox while retaining its persistent state. + * + * @generated from rpc openshell.v1.OpenShell.StopSandbox + */ + stopSandbox: { + methodKind: "unary"; + input: typeof StopSandboxRequestSchema; + output: typeof SandboxResponseSchema; + }, + /** + * Start a previously stopped sandbox. + * + * @generated from rpc openshell.v1.OpenShell.StartSandbox + */ + startSandbox: { + methodKind: "unary"; + input: typeof StartSandboxRequestSchema; + output: typeof SandboxResponseSchema; + }, + /** + * Freeze a ready sandbox and retain its memory state for a later resume. + * Requires a compute driver and isolation backend that support state + * retention. + * + * @generated from rpc openshell.v1.OpenShell.SuspendSandbox + */ + suspendSandbox: { + methodKind: "unary"; + input: typeof SuspendSandboxRequestSchema; + output: typeof SandboxResponseSchema; + }, + /** + * Restore a suspended sandbox in a new runtime generation. + * + * @generated from rpc openshell.v1.OpenShell.ResumeSandbox + */ + resumeSandbox: { + methodKind: "unary"; + input: typeof ResumeSandboxRequestSchema; + output: typeof SandboxResponseSchema; + }, + /** + * Create a short-lived SSH session for a sandbox. + * + * @generated from rpc openshell.v1.OpenShell.CreateSshSession + */ + createSshSession: { + methodKind: "unary"; + input: typeof CreateSshSessionRequestSchema; + output: typeof CreateSshSessionResponseSchema; + }, + /** + * Create or update a sandbox HTTP service endpoint for local routing. + * + * @generated from rpc openshell.v1.OpenShell.ExposeService + */ + exposeService: { + methodKind: "unary"; + input: typeof ExposeServiceRequestSchema; + output: typeof ServiceEndpointResponseSchema; + }, + /** + * Fetch one sandbox HTTP service endpoint. + * + * @generated from rpc openshell.v1.OpenShell.GetService + */ + getService: { + methodKind: "unary"; + input: typeof GetServiceRequestSchema; + output: typeof ServiceEndpointResponseSchema; + }, + /** + * List sandbox HTTP service endpoints. + * + * @generated from rpc openshell.v1.OpenShell.ListServices + */ + listServices: { + methodKind: "unary"; + input: typeof ListServicesRequestSchema; + output: typeof ListServicesResponseSchema; + }, + /** + * Delete one sandbox HTTP service endpoint. + * + * @generated from rpc openshell.v1.OpenShell.DeleteService + */ + deleteService: { + methodKind: "unary"; + input: typeof DeleteServiceRequestSchema; + output: typeof DeleteServiceResponseSchema; + }, + /** + * Revoke a previously issued SSH session. + * + * @generated from rpc openshell.v1.OpenShell.RevokeSshSession + */ + revokeSshSession: { + methodKind: "unary"; + input: typeof RevokeSshSessionRequestSchema; + output: typeof RevokeSshSessionResponseSchema; + }, + /** + * Execute a command in a ready sandbox and stream output. + * + * @generated from rpc openshell.v1.OpenShell.ExecSandbox + */ + execSandbox: { + methodKind: "server_streaming"; + input: typeof ExecSandboxRequestSchema; + output: typeof ExecSandboxEventSchema; + }, + /** + * Forward one CLI-side TCP connection to a loopback TCP target in a sandbox. + * + * @generated from rpc openshell.v1.OpenShell.ForwardTcp + */ + forwardTcp: { + methodKind: "bidi_streaming"; + input: typeof TcpForwardFrameSchema; + output: typeof TcpForwardFrameSchema; + }, + /** + * Execute an interactive command with bidirectional stdin/stdout streaming. + * The first client message MUST carry an ExecSandboxInput with the start + * variant. Subsequent messages carry stdin bytes or window resize events. + * + * @generated from rpc openshell.v1.OpenShell.ExecSandboxInteractive + */ + execSandboxInteractive: { + methodKind: "bidi_streaming"; + input: typeof ExecSandboxInputSchema; + output: typeof ExecSandboxEventSchema; + }, + /** + * Create a provider. + * + * @generated from rpc openshell.v1.OpenShell.CreateProvider + */ + createProvider: { + methodKind: "unary"; + input: typeof CreateProviderRequestSchema; + output: typeof ProviderResponseSchema; + }, + /** + * Fetch a provider by name. + * + * @generated from rpc openshell.v1.OpenShell.GetProvider + */ + getProvider: { + methodKind: "unary"; + input: typeof GetProviderRequestSchema; + output: typeof ProviderResponseSchema; + }, + /** + * Export selected usable runtime credentials. Only directly authenticated + * mTLS operators may call this method; refresh material is never returned. + * + * @generated from rpc openshell.v1.OpenShell.GetProviderCredentials + */ + getProviderCredentials: { + methodKind: "unary"; + input: typeof GetProviderCredentialsRequestSchema; + output: typeof GetProviderCredentialsResponseSchema; + }, + /** + * List providers. + * + * @generated from rpc openshell.v1.OpenShell.ListProviders + */ + listProviders: { + methodKind: "unary"; + input: typeof ListProvidersRequestSchema; + output: typeof ListProvidersResponseSchema; + }, + /** + * List available provider type profiles. + * + * @generated from rpc openshell.v1.OpenShell.ListProviderProfiles + */ + listProviderProfiles: { + methodKind: "unary"; + input: typeof ListProviderProfilesRequestSchema; + output: typeof ListProviderProfilesResponseSchema; + }, + /** + * Fetch one provider type profile by id. + * + * @generated from rpc openshell.v1.OpenShell.GetProviderProfile + */ + getProviderProfile: { + methodKind: "unary"; + input: typeof GetProviderProfileRequestSchema; + output: typeof ProviderProfileResponseSchema; + }, + /** + * Import custom provider type profiles. + * + * @generated from rpc openshell.v1.OpenShell.ImportProviderProfiles + */ + importProviderProfiles: { + methodKind: "unary"; + input: typeof ImportProviderProfilesRequestSchema; + output: typeof ImportProviderProfilesResponseSchema; + }, + /** + * Update an existing custom provider type profile. + * + * @generated from rpc openshell.v1.OpenShell.UpdateProviderProfiles + */ + updateProviderProfiles: { + methodKind: "unary"; + input: typeof UpdateProviderProfilesRequestSchema; + output: typeof UpdateProviderProfilesResponseSchema; + }, + /** + * Validate provider type profiles without registering them. + * + * @generated from rpc openshell.v1.OpenShell.LintProviderProfiles + */ + lintProviderProfiles: { + methodKind: "unary"; + input: typeof LintProviderProfilesRequestSchema; + output: typeof LintProviderProfilesResponseSchema; + }, + /** + * Update an existing provider by name. + * + * @generated from rpc openshell.v1.OpenShell.UpdateProvider + */ + updateProvider: { + methodKind: "unary"; + input: typeof UpdateProviderRequestSchema; + output: typeof ProviderResponseSchema; + }, + /** + * Fetch refresh status for one provider or provider credential. + * + * @generated from rpc openshell.v1.OpenShell.GetProviderRefreshStatus + */ + getProviderRefreshStatus: { + methodKind: "unary"; + input: typeof GetProviderRefreshStatusRequestSchema; + output: typeof GetProviderRefreshStatusResponseSchema; + }, + /** + * Configure gateway-owned refresh material for one provider credential. + * + * @generated from rpc openshell.v1.OpenShell.ConfigureProviderRefresh + */ + configureProviderRefresh: { + methodKind: "unary"; + input: typeof ConfigureProviderRefreshRequestSchema; + output: typeof ConfigureProviderRefreshResponseSchema; + }, + /** + * Record a gateway-owned refresh request for one provider credential. + * + * @generated from rpc openshell.v1.OpenShell.RotateProviderCredential + */ + rotateProviderCredential: { + methodKind: "unary"; + input: typeof RotateProviderCredentialRequestSchema; + output: typeof RotateProviderCredentialResponseSchema; + }, + /** + * Delete gateway-owned refresh configuration for one provider credential. + * + * @generated from rpc openshell.v1.OpenShell.DeleteProviderRefresh + */ + deleteProviderRefresh: { + methodKind: "unary"; + input: typeof DeleteProviderRefreshRequestSchema; + output: typeof DeleteProviderRefreshResponseSchema; + }, + /** + * Delete a provider by name. + * + * @generated from rpc openshell.v1.OpenShell.DeleteProvider + */ + deleteProvider: { + methodKind: "unary"; + input: typeof DeleteProviderRequestSchema; + output: typeof DeleteProviderResponseSchema; + }, + /** + * Delete a custom provider type profile by id. + * + * @generated from rpc openshell.v1.OpenShell.DeleteProviderProfile + */ + deleteProviderProfile: { + methodKind: "unary"; + input: typeof DeleteProviderProfileRequestSchema; + output: typeof DeleteProviderProfileResponseSchema; + }, + /** + * Get sandbox settings by id (called by users, and by supervisors at startup + * and in their poll loop). A supervisor whose session pushes configuration + * receives later updates over ConnectSupervisor and stops polling. + * + * @generated from rpc openshell.v1.OpenShell.GetSandboxConfig + */ + getSandboxConfig: { + methodKind: "unary"; + input: typeof GetSandboxConfigRequestSchema; + output: typeof GetSandboxConfigResponseSchema; + }, + /** + * Get gateway-global settings (read-only runtime configuration; any + * authenticated user may read these without requiring Platform Admin). + * + * Scope-only (no role): scopes are granted by the IdP at token issuance, + * orthogonal to workspace membership. Deployments that enable scope + * enforcement configure the IdP to grant config:read (or openshell:all) + * to all sandbox users, so this does not block least-privilege flows. + * + * @generated from rpc openshell.v1.OpenShell.GetGatewayConfig + */ + getGatewayConfig: { + methodKind: "unary"; + input: typeof GetGatewayConfigRequestSchema; + output: typeof GetGatewayConfigResponseSchema; + }, + /** + * Update settings or policy at sandbox or global scope. + * + * @generated from rpc openshell.v1.OpenShell.UpdateConfig + */ + updateConfig: { + methodKind: "unary"; + input: typeof UpdateConfigRequestSchema; + output: typeof UpdateConfigResponseSchema; + }, + /** + * Get the load status of a specific policy version. + * + * @generated from rpc openshell.v1.OpenShell.GetSandboxPolicyStatus + */ + getSandboxPolicyStatus: { + methodKind: "unary"; + input: typeof GetSandboxPolicyStatusRequestSchema; + output: typeof GetSandboxPolicyStatusResponseSchema; + }, + /** + * List policy history for a sandbox. + * + * @generated from rpc openshell.v1.OpenShell.ListSandboxPolicies + */ + listSandboxPolicies: { + methodKind: "unary"; + input: typeof ListSandboxPoliciesRequestSchema; + output: typeof ListSandboxPoliciesResponseSchema; + }, + /** + * Report policy load result (called by sandbox after reload attempt). + * + * @generated from rpc openshell.v1.OpenShell.ReportPolicyStatus + */ + reportPolicyStatus: { + methodKind: "unary"; + input: typeof ReportPolicyStatusRequestSchema; + output: typeof ReportPolicyStatusResponseSchema; + }, + /** + * Replace the gateway's observed tool server endpoint status for one sandbox. + * + * @generated from rpc openshell.v1.OpenShell.ReportEndpointStatus + */ + reportEndpointStatus: { + methodKind: "unary"; + input: typeof ReportEndpointStatusRequestSchema; + output: typeof ReportEndpointStatusResponseSchema; + }, + /** + * Report installed provider state for the current ConnectSupervisor session. + * Replacing or losing that session invalidates its observations. + * + * @generated from rpc openshell.v1.OpenShell.ReportProviderReadiness + */ + reportProviderReadiness: { + methodKind: "unary"; + input: typeof ReportProviderReadinessRequestSchema; + output: typeof ReportProviderReadinessResponseSchema; + }, + /** + * Register startup and acknowledge an exact validated runtime configuration. + * + * @generated from rpc openshell.v1.OpenShell.ReportSandboxConfiguration + */ + reportSandboxConfiguration: { + methodKind: "unary"; + input: typeof ReportSandboxConfigurationRequestSchema; + output: typeof ReportSandboxConfigurationResponseSchema; + }, + /** + * Get provider environment for a sandbox (called by the sandbox supervisor at + * startup and by its poll loop). Polling projection of the provider + * environment delivered over ConnectSupervisor; removed with the polling RPCs. + * + * @generated from rpc openshell.v1.OpenShell.GetSandboxProviderEnvironment + */ + getSandboxProviderEnvironment: { + methodKind: "unary"; + input: typeof GetSandboxProviderEnvironmentRequestSchema; + output: typeof GetSandboxProviderEnvironmentResponseSchema; + }, + /** + * Exchange a stored provider subject token for an intermediate token scoped + * to the calling supervisor's SPIFFE identity. + * + * @generated from rpc openshell.v1.OpenShell.ExchangeProviderSubjectToken + */ + exchangeProviderSubjectToken: { + methodKind: "unary"; + input: typeof ExchangeProviderSubjectTokenRequestSchema; + output: typeof ExchangeProviderSubjectTokenResponseSchema; + }, + /** + * Fetch recent sandbox logs (one-shot). + * + * @generated from rpc openshell.v1.OpenShell.GetSandboxLogs + */ + getSandboxLogs: { + methodKind: "unary"; + input: typeof GetSandboxLogsRequestSchema; + output: typeof GetSandboxLogsResponseSchema; + }, + /** + * Push sandbox supervisor logs to the server (client-streaming). + * + * @generated from rpc openshell.v1.OpenShell.PushSandboxLogs + */ + pushSandboxLogs: { + methodKind: "client_streaming"; + input: typeof PushSandboxLogsRequestSchema; + output: typeof PushSandboxLogsResponseSchema; + }, + /** + * Persistent supervisor-to-gateway session (bidirectional streaming). + * + * The supervisor opens this stream at startup and keeps it alive for the + * sandbox lifetime. The gateway uses it to coordinate relay channels for + * SSH connect, ExecSandbox, targetable sandbox services, and configuration + * delivery. Supervisors advertise optional stream features in + * SupervisorHello, and the gateway sends only payloads the supervisor + * advertises. Raw service bytes flow over RelayStream calls (separate HTTP/2 + * streams on the same connection), not over this stream. + * + * @generated from rpc openshell.v1.OpenShell.ConnectSupervisor + */ + connectSupervisor: { + methodKind: "bidi_streaming"; + input: typeof SupervisorMessageSchema; + output: typeof GatewayMessageSchema; + }, + /** + * Persist the canonical main process result before the supervisor exits. + * + * @generated from rpc openshell.v1.OpenShell.ReportMainProcessExit + */ + reportMainProcessExit: { + methodKind: "unary"; + input: typeof ReportMainProcessExitRequestSchema; + output: typeof ReportMainProcessExitResponseSchema; + }, + /** + * Confirm that foreground terminal delivery completed naturally. + * + * @generated from rpc openshell.v1.OpenShell.FinalizeMainProcessExit + */ + finalizeMainProcessExit: { + methodKind: "unary"; + input: typeof FinalizeMainProcessExitRequestSchema; + output: typeof FinalizeMainProcessExitResponseSchema; + }, + /** + * Raw byte relay between supervisor and gateway. + * + * The supervisor initiates this call after receiving a RelayOpen message + * on its ConnectSupervisor stream. The first RelayFrame carries a + * RelayInit with the channel_id to associate the new HTTP/2 stream with + * the pending relay slot on the gateway. Subsequent frames carry raw bytes in either + * direction between the gateway-side waiter (ForwardTcp / exec handler) + * and the supervisor-side target bridge. + * + * This rides the same TCP+TLS+HTTP/2 connection as ConnectSupervisor — + * no new TLS handshake, no reverse HTTP CONNECT. + * + * @generated from rpc openshell.v1.OpenShell.RelayStream + */ + relayStream: { + methodKind: "bidi_streaming"; + input: typeof RelayFrameSchema; + output: typeof RelayFrameSchema; + }, + /** + * Internal gateway-to-gateway relay forwarding. + * + * A gateway replica that receives a user request for a sandbox whose + * supervisor session is owned by a different replica opens this stream to the + * owner. The first frame carries PeerRelayInit; subsequent frames carry raw + * bytes in either direction. This RPC is authenticated as a gateway peer, not + * as a user or sandbox supervisor. + * + * @generated from rpc openshell.v1.OpenShell.PeerRelay + */ + peerRelay: { + methodKind: "bidi_streaming"; + input: typeof PeerRelayFrameSchema; + output: typeof PeerRelayFrameSchema; + }, + /** + * Internal gateway-to-owner forwarding for supervisor-bound state. + * + * @generated from rpc openshell.v1.OpenShell.PeerReportProviderReadiness + */ + peerReportProviderReadiness: { + methodKind: "unary"; + input: typeof ReportProviderReadinessRequestSchema; + output: typeof ReportProviderReadinessResponseSchema; + }, + /** + * @generated from rpc openshell.v1.OpenShell.PeerReportEndpointStatus + */ + peerReportEndpointStatus: { + methodKind: "unary"; + input: typeof ReportEndpointStatusRequestSchema; + output: typeof ReportEndpointStatusResponseSchema; + }, + /** + * @generated from rpc openshell.v1.OpenShell.PeerGetSandboxProviderStatus + */ + peerGetSandboxProviderStatus: { + methodKind: "unary"; + input: typeof GetSandboxProviderStatusRequestSchema; + output: typeof GetSandboxProviderStatusResponseSchema; + }, + /** + * Best-effort notification to the replica that owns a supervisor session. + * The receiver rebuilds snapshots from authoritative state. + * + * @generated from rpc openshell.v1.OpenShell.PeerNotifyConfigUpdate + */ + peerNotifyConfigUpdate: { + methodKind: "unary"; + input: typeof PeerNotifyConfigUpdateRequestSchema; + output: typeof PeerNotifyConfigUpdateResponseSchema; + }, + /** + * Watch a sandbox and stream updates. + * + * This stream can include: + * - Sandbox status snapshots (phase/status) + * - OpenShell server process logs correlated by sandbox_id + * - Platform events correlated to the sandbox + * + * @generated from rpc openshell.v1.OpenShell.WatchSandbox + */ + watchSandbox: { + methodKind: "server_streaming"; + input: typeof WatchSandboxRequestSchema; + output: typeof SandboxStreamEventSchema; + }, + /** + * Submit denial analysis results from sandbox (summaries + proposed chunks). + * + * @generated from rpc openshell.v1.OpenShell.SubmitPolicyAnalysis + */ + submitPolicyAnalysis: { + methodKind: "unary"; + input: typeof SubmitPolicyAnalysisRequestSchema; + output: typeof SubmitPolicyAnalysisResponseSchema; + }, + /** + * Get draft policy recommendations for a sandbox. + * + * @generated from rpc openshell.v1.OpenShell.GetDraftPolicy + */ + getDraftPolicy: { + methodKind: "unary"; + input: typeof GetDraftPolicyRequestSchema; + output: typeof GetDraftPolicyResponseSchema; + }, + /** + * Approve a single draft policy chunk (merges into active policy). + * + * @generated from rpc openshell.v1.OpenShell.ApproveDraftChunk + */ + approveDraftChunk: { + methodKind: "unary"; + input: typeof ApproveDraftChunkRequestSchema; + output: typeof ApproveDraftChunkResponseSchema; + }, + /** + * Reject a single draft policy chunk. + * + * @generated from rpc openshell.v1.OpenShell.RejectDraftChunk + */ + rejectDraftChunk: { + methodKind: "unary"; + input: typeof RejectDraftChunkRequestSchema; + output: typeof RejectDraftChunkResponseSchema; + }, + /** + * Approve all pending draft chunks (skips security-flagged unless forced). + * + * @generated from rpc openshell.v1.OpenShell.ApproveAllDraftChunks + */ + approveAllDraftChunks: { + methodKind: "unary"; + input: typeof ApproveAllDraftChunksRequestSchema; + output: typeof ApproveAllDraftChunksResponseSchema; + }, + /** + * Edit a pending draft chunk in-place (e.g. narrow allowed_ips). + * + * @generated from rpc openshell.v1.OpenShell.EditDraftChunk + */ + editDraftChunk: { + methodKind: "unary"; + input: typeof EditDraftChunkRequestSchema; + output: typeof EditDraftChunkResponseSchema; + }, + /** + * Reverse an approval (remove merged rule from active policy). + * + * @generated from rpc openshell.v1.OpenShell.UndoDraftChunk + */ + undoDraftChunk: { + methodKind: "unary"; + input: typeof UndoDraftChunkRequestSchema; + output: typeof UndoDraftChunkResponseSchema; + }, + /** + * Clear all pending draft chunks for a sandbox. + * + * @generated from rpc openshell.v1.OpenShell.ClearDraftChunks + */ + clearDraftChunks: { + methodKind: "unary"; + input: typeof ClearDraftChunksRequestSchema; + output: typeof ClearDraftChunksResponseSchema; + }, + /** + * Get decision history for a sandbox's draft policy. + * + * @generated from rpc openshell.v1.OpenShell.GetDraftHistory + */ + getDraftHistory: { + methodKind: "unary"; + input: typeof GetDraftHistoryRequestSchema; + output: typeof GetDraftHistoryResponseSchema; + }, + /** + * Exchange a sandbox-bootstrap credential (e.g. a Kubernetes projected + * ServiceAccount token) for a gateway-minted JWT bound to the calling + * sandbox's UUID. Used by the Kubernetes driver path; singleplayer + * drivers receive the gateway JWT directly from the create-sandbox flow + * and never call this RPC. + * + * @generated from rpc openshell.v1.OpenShell.IssueSandboxToken + */ + issueSandboxToken: { + methodKind: "unary"; + input: typeof IssueSandboxTokenRequestSchema; + output: typeof IssueSandboxTokenResponseSchema; + }, + /** + * Renew the calling sandbox's gateway JWT. Older tokens remain valid + * until their own expiry; deployments should keep token TTLs short to + * bound replay exposure. The supervisor calls this from a background + * task at ~80% of the token's lifetime; the new token is cached in + * memory only — the on-disk bootstrap file is intentionally not + * rewritten. + * + * @generated from rpc openshell.v1.OpenShell.RefreshSandboxToken + */ + refreshSandboxToken: { + methodKind: "unary"; + input: typeof RefreshSandboxTokenRequestSchema; + output: typeof RefreshSandboxTokenResponseSchema; + }, + /** + * Create a workspace. + * + * @generated from rpc openshell.v1.OpenShell.CreateWorkspace + */ + createWorkspace: { + methodKind: "unary"; + input: typeof CreateWorkspaceRequestSchema; + output: typeof CreateWorkspaceResponseSchema; + }, + /** + * Fetch a workspace by name. + * + * @generated from rpc openshell.v1.OpenShell.GetWorkspace + */ + getWorkspace: { + methodKind: "unary"; + input: typeof GetWorkspaceRequestSchema; + output: typeof GetWorkspaceResponseSchema; + }, + /** + * List workspaces. + * + * @generated from rpc openshell.v1.OpenShell.ListWorkspaces + */ + listWorkspaces: { + methodKind: "unary"; + input: typeof ListWorkspacesRequestSchema; + output: typeof ListWorkspacesResponseSchema; + }, + /** + * Delete a workspace by name. + * + * @generated from rpc openshell.v1.OpenShell.DeleteWorkspace + */ + deleteWorkspace: { + methodKind: "unary"; + input: typeof DeleteWorkspaceRequestSchema; + output: typeof DeleteWorkspaceResponseSchema; + }, + /** + * Add a member to a workspace. + * + * @generated from rpc openshell.v1.OpenShell.AddWorkspaceMember + */ + addWorkspaceMember: { + methodKind: "unary"; + input: typeof AddWorkspaceMemberRequestSchema; + output: typeof AddWorkspaceMemberResponseSchema; + }, + /** + * Remove a member from a workspace. + * + * @generated from rpc openshell.v1.OpenShell.RemoveWorkspaceMember + */ + removeWorkspaceMember: { + methodKind: "unary"; + input: typeof RemoveWorkspaceMemberRequestSchema; + output: typeof RemoveWorkspaceMemberResponseSchema; + }, + /** + * List members of a workspace. + * + * @generated from rpc openshell.v1.OpenShell.ListWorkspaceMembers + */ + listWorkspaceMembers: { + methodKind: "unary"; + input: typeof ListWorkspaceMembersRequestSchema; + output: typeof ListWorkspaceMembersResponseSchema; + }, +}> = /*@__PURE__*/ + serviceDesc(file_openshell, 0); + +/** + * Optional sandbox mutations are separate from OpenShell so existing generated + * OpenShell server implementations remain source-compatible. + * + * @generated from service openshell.v1.SandboxUpdates + */ +export const SandboxUpdates: GenService<{ + /** + * Update the workload image, command, environment, labels, or annotations of a + * stopped sandbox while preserving its identity and retained storage. Requires + * compute-driver support for the selected changes and explicit gateway activation + * of sandbox updates. + * + * @generated from rpc openshell.v1.SandboxUpdates.UpdateSandbox + */ + updateSandbox: { + methodKind: "unary"; + input: typeof UpdateSandboxRequestSchema; + output: typeof SandboxResponseSchema; + }, +}> = /*@__PURE__*/ + serviceDesc(file_openshell, 1); + diff --git a/src/gen/options_pb.ts b/src/gen/options_pb.ts new file mode 100644 index 0000000..d25f345 --- /dev/null +++ b/src/gen/options_pb.ts @@ -0,0 +1,80 @@ +// SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +// @generated by protoc-gen-es v2.12.1 with parameter "target=ts,import_extension=js" +// @generated from file options.proto (package openshell.options.v1, syntax proto3) +/* eslint-disable */ + +import type { GenExtension, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2"; +import { extDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv2"; +import type { FieldOptions, MethodOptions } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_descriptor } from "@bufbuild/protobuf/wkt"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file options.proto. + */ +export const file_options: GenFile = /*@__PURE__*/ + fileDesc("Cg1vcHRpb25zLnByb3RvEhRvcGVuc2hlbGwub3B0aW9ucy52MSJiChFBdXRob3JpemF0aW9uUnVsZRIRCglhdXRoX21vZGUYASABKAkSFgoOd29ya3NwYWNlX3JvbGUYAiABKAkSEwoLZ2xvYmFsX3JvbGUYAyABKAkSDQoFc2NvcGUYBCABKAk6bwoNYXV0aG9yaXphdGlvbhIeLmdvb2dsZS5wcm90b2J1Zi5NZXRob2RPcHRpb25zGNCGAyABKAsyJy5vcGVuc2hlbGwub3B0aW9ucy52MS5BdXRob3JpemF0aW9uUnVsZVINYXV0aG9yaXphdGlvbjo3CgZzZWNyZXQSHS5nb29nbGUucHJvdG9idWYuRmllbGRPcHRpb25zGNGGAyABKAhSBnNlY3JldGIGcHJvdG8z", [file_google_protobuf_descriptor]); + +/** + * Per-method authorization rule. Consumed at runtime by the gateway's + * descriptor-pool-based auth table to enforce auth mode, role, and scope. + * + * @generated from message openshell.options.v1.AuthorizationRule + */ +export type AuthorizationRule = Message<"openshell.options.v1.AuthorizationRule"> & { + /** + * Authentication mode: "bearer", "sandbox", "dual", "peer", "operator", + * or "unauthenticated". Operator requires a verified mTLS operator certificate. + * + * @generated from field: string auth_mode = 1; + */ + authMode: string; + + /** + * Minimum workspace-level role required (checked by handler via + * authorize_workspace): "user" or "admin". Mutually exclusive with + * global_role. + * + * @generated from field: string workspace_role = 2; + */ + workspaceRole: string; + + /** + * Global role required (checked by middleware via OIDC claims): + * "platform_admin". Mutually exclusive with workspace_role. + * + * @generated from field: string global_role = 3; + */ + globalRole: string; + + /** + * Required OIDC scope on the bearer path (e.g. "sandbox:read"). + * + * @generated from field: string scope = 4; + */ + scope: string; +}; + +/** + * Describes the message openshell.options.v1.AuthorizationRule. + * Use `create(AuthorizationRuleSchema)` to create a new message. + */ +export const AuthorizationRuleSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_options, 0); + +/** + * Authorization metadata for a gRPC method. + * + * @generated from extension: openshell.options.v1.AuthorizationRule authorization = 50000; + */ +export const authorization: GenExtension = /*@__PURE__*/ + extDesc(file_options, 0); + +/** + * @generated from extension: bool secret = 50001; + */ +export const secret: GenExtension = /*@__PURE__*/ + extDesc(file_options, 1); + diff --git a/src/gen/sandbox_pb.ts b/src/gen/sandbox_pb.ts new file mode 100644 index 0000000..9e96e8d --- /dev/null +++ b/src/gen/sandbox_pb.ts @@ -0,0 +1,1639 @@ +// SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +// @generated by protoc-gen-es v2.12.1 with parameter "target=ts,import_extension=js" +// @generated from file sandbox.proto (package openshell.sandbox.v1, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2"; +import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv2"; +import type { Duration } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_duration, file_google_protobuf_struct } from "@bufbuild/protobuf/wkt"; +import type { WorkspaceSelector } from "./datamodel_pb.js"; +import { file_datamodel } from "./datamodel_pb.js"; +import type { JsonObject, Message } from "@bufbuild/protobuf"; + +/** + * Describes the file sandbox.proto. + */ +export const file_sandbox: GenFile = /*@__PURE__*/ + fileDesc("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", [file_google_protobuf_struct, file_google_protobuf_duration, file_datamodel]); + +/** + * Sandbox security policy configuration. + * + * @generated from message openshell.sandbox.v1.SandboxPolicy + */ +export type SandboxPolicy = Message<"openshell.sandbox.v1.SandboxPolicy"> & { + /** + * Policy version. + * + * @generated from field: uint32 version = 1; + */ + version: number; + + /** + * Filesystem access policy. + * + * @generated from field: openshell.sandbox.v1.FilesystemPolicy filesystem = 2; + */ + filesystem?: FilesystemPolicy | undefined; + + /** + * Landlock configuration. + * + * @generated from field: openshell.sandbox.v1.LandlockPolicy landlock = 3; + */ + landlock?: LandlockPolicy | undefined; + + /** + * Process execution policy. + * + * @generated from field: openshell.sandbox.v1.ProcessPolicy process = 4; + */ + process?: ProcessPolicy | undefined; + + /** + * Network access policies keyed by name (e.g. "claude_code", "gitlab"). + * + * @generated from field: map network_policies = 5; + */ + networkPolicies: { [key: string]: NetworkPolicyRule }; + + /** + * Reusable supervisor middleware configs for network egress, keyed by their + * policy-local names. At most 10 configs are accepted, and at most 10 stages + * can be selected per request. + * + * @generated from field: map network_middlewares = 6; + */ + networkMiddlewares: { [key: string]: NetworkMiddlewareConfig }; +}; + +/** + * Describes the message openshell.sandbox.v1.SandboxPolicy. + * Use `create(SandboxPolicySchema)` to create a new message. + */ +export const SandboxPolicySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_sandbox, 0); + +/** + * Filesystem access policy. + * + * @generated from message openshell.sandbox.v1.FilesystemPolicy + */ +export type FilesystemPolicy = Message<"openshell.sandbox.v1.FilesystemPolicy"> & { + /** + * Automatically include the workdir as read-write. + * + * @generated from field: bool include_workdir = 1; + */ + includeWorkdir: boolean; + + /** + * Read-only directory allow list. + * + * @generated from field: repeated string read_only = 2; + */ + readOnly: string[]; + + /** + * Read-write directory allow list. + * + * @generated from field: repeated string read_write = 3; + */ + readWrite: string[]; +}; + +/** + * Describes the message openshell.sandbox.v1.FilesystemPolicy. + * Use `create(FilesystemPolicySchema)` to create a new message. + */ +export const FilesystemPolicySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_sandbox, 1); + +/** + * Landlock policy configuration. + * + * @generated from message openshell.sandbox.v1.LandlockPolicy + */ +export type LandlockPolicy = Message<"openshell.sandbox.v1.LandlockPolicy"> & { + /** + * Compatibility mode (e.g. "best_effort", "hard_requirement"). + * + * @generated from field: string compatibility = 1; + */ + compatibility: string; +}; + +/** + * Describes the message openshell.sandbox.v1.LandlockPolicy. + * Use `create(LandlockPolicySchema)` to create a new message. + */ +export const LandlockPolicySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_sandbox, 2); + +/** + * Process execution policy. + * + * @generated from message openshell.sandbox.v1.ProcessPolicy + */ +export type ProcessPolicy = Message<"openshell.sandbox.v1.ProcessPolicy"> & { + /** + * User name to run the sandboxed process as. + * + * @generated from field: string run_as_user = 1; + */ + runAsUser: string; + + /** + * Group name to run the sandboxed process as. + * + * @generated from field: string run_as_group = 2; + */ + runAsGroup: string; +}; + +/** + * Describes the message openshell.sandbox.v1.ProcessPolicy. + * Use `create(ProcessPolicySchema)` to create a new message. + */ +export const ProcessPolicySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_sandbox, 3); + +/** + * A named network access policy rule. + * + * @generated from message openshell.sandbox.v1.NetworkPolicyRule + */ +export type NetworkPolicyRule = Message<"openshell.sandbox.v1.NetworkPolicyRule"> & { + /** + * Human-readable name for this policy rule. + * + * @generated from field: string name = 1; + */ + name: string; + + /** + * Allowed endpoint (host:port) pairs. + * + * @generated from field: repeated openshell.sandbox.v1.NetworkEndpoint endpoints = 2; + */ + endpoints: NetworkEndpoint[]; + + /** + * Allowed binary identities. + * + * @generated from field: repeated openshell.sandbox.v1.NetworkBinary binaries = 3; + */ + binaries: NetworkBinary[]; +}; + +/** + * Describes the message openshell.sandbox.v1.NetworkPolicyRule. + * Use `create(NetworkPolicyRuleSchema)` to create a new message. + */ +export const NetworkPolicyRuleSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_sandbox, 4); + +/** + * A reusable middleware config selected for admitted egress by host. + * + * @generated from message openshell.sandbox.v1.NetworkMiddlewareConfig + */ +export type NetworkMiddlewareConfig = Message<"openshell.sandbox.v1.NetworkMiddlewareConfig"> & { + /** + * Human-readable name for this middleware config. + * + * @generated from field: string name = 1; + */ + name: string; + + /** + * Built-in middleware name or operator-owned registration name. + * + * @generated from field: string middleware = 2; + */ + middleware: string; + + /** + * Service-specific configuration. + * + * @generated from field: google.protobuf.Struct config = 3; + */ + config?: JsonObject | undefined; + + /** + * Failure behavior: "fail_closed" (default) or "fail_open". + * + * @generated from field: string on_error = 4; + */ + onError: string; + + /** + * Host selector controlling which admitted destinations use this config. + * + * @generated from field: openshell.sandbox.v1.MiddlewareEndpointSelector endpoints = 5; + */ + endpoints?: MiddlewareEndpointSelector | undefined; + + /** + * Execution order. Values must be unique within a policy; lower values run first. + * + * @generated from field: int32 order = 6; + */ + order: number; +}; + +/** + * Describes the message openshell.sandbox.v1.NetworkMiddlewareConfig. + * Use `create(NetworkMiddlewareConfigSchema)` to create a new message. + */ +export const NetworkMiddlewareConfigSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_sandbox, 5); + +/** + * Host selector controlling which admitted destinations use a middleware config. + * + * @generated from message openshell.sandbox.v1.MiddlewareEndpointSelector + */ +export type MiddlewareEndpointSelector = Message<"openshell.sandbox.v1.MiddlewareEndpointSelector"> & { + /** + * Exact host or DNS glob patterns included in the selection. Include and + * exclude accept at most 32 combined patterns. + * + * @generated from field: repeated string include = 1; + */ + include: string[]; + + /** + * Exact host or DNS glob patterns removed from the selection. + * Exclusions take precedence over inclusions. + * + * @generated from field: repeated string exclude = 2; + */ + exclude: string[]; +}; + +/** + * Describes the message openshell.sandbox.v1.MiddlewareEndpointSelector. + * Use `create(MiddlewareEndpointSelectorSchema)` to create a new message. + */ +export const MiddlewareEndpointSelectorSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_sandbox, 6); + +/** + * Binds a policy endpoint to static credentials from a sandbox provider. + * + * @generated from message openshell.sandbox.v1.NetworkCredentialBinding + */ +export type NetworkCredentialBinding = Message<"openshell.sandbox.v1.NetworkCredentialBinding"> & { + /** + * Name of the provider attached to this sandbox whose static credentials + * may be resolved for requests admitted by this endpoint. + * + * @generated from field: string provider = 1; + */ + provider: string; +}; + +/** + * Describes the message openshell.sandbox.v1.NetworkCredentialBinding. + * Use `create(NetworkCredentialBindingSchema)` to create a new message. + */ +export const NetworkCredentialBindingSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_sandbox, 7); + +/** + * A network endpoint (host + port) with optional L7 inspection config. + * + * @generated from message openshell.sandbox.v1.NetworkEndpoint + */ +export type NetworkEndpoint = Message<"openshell.sandbox.v1.NetworkEndpoint"> & { + /** + * Hostname or host glob pattern. Exact match is case-insensitive. + * Glob patterns use "." as delimiter: "*.example.com" matches a single + * subdomain label, "**.example.com" matches across labels. + * + * @generated from field: string host = 1; + */ + host: string; + + /** + * Single port (backwards compat). Use `ports` for multiple ports. + * Mutually exclusive with `ports` — if both are set, `ports` takes precedence. + * + * @generated from field: uint32 port = 2; + */ + port: number; + + /** + * Endpoint protocol. "tcp" and "" select L4-only handling; "rest", + * "websocket", "graphql", "sql", "json-rpc", and "mcp" select L7 inspection. + * + * @generated from field: string protocol = 3; + */ + protocol: string; + + /** + * TLS handling. Unspecified enables automatic detection and termination. + * + * @generated from field: openshell.sandbox.v1.NetworkTlsMode tls = 4; + */ + tls: NetworkTlsMode; + + /** + * Enforcement mode. Unspecified preserves the audit default. + * + * @generated from field: openshell.sandbox.v1.NetworkEnforcementMode enforcement = 5; + */ + enforcement: NetworkEnforcementMode; + + /** + * Access preset shorthand. Unspecified means no preset. + * Mutually exclusive with rules. + * + * @generated from field: openshell.sandbox.v1.NetworkAccessPreset access = 6; + */ + access: NetworkAccessPreset; + + /** + * Explicit L7 rules (mutually exclusive with access). + * + * @generated from field: repeated openshell.sandbox.v1.L7Rule rules = 7; + */ + rules: L7Rule[]; + + /** + * Allowed resolved IP addresses or CIDR ranges for this endpoint. + * When non-empty, the SSRF internal-IP check is replaced by an allowlist check: + * - If host is also set: domain must resolve to an IP in this list. + * - If host is empty: any domain is allowed as long as it resolves to an IP in this list. + * Supports exact IPs ("10.0.5.20") and CIDR notation ("10.0.5.0/24"). + * Loopback (127.0.0.0/8) and link-local (169.254.0.0/16) are always blocked + * regardless of this field. + * + * @generated from field: repeated string allowed_ips = 8; + */ + allowedIps: string[]; + + /** + * Multiple ports. When non-empty, this endpoint covers all listed ports. + * If `port` is set and `ports` is empty, `port` is normalized to `ports: [port]`. + * If both are set, `ports` takes precedence. + * + * @generated from field: repeated uint32 ports = 9; + */ + ports: number[]; + + /** + * Explicit L7 deny rules. When present, requests matching any deny rule + * are blocked even if they match an allow rule or access preset. + * Deny rules take precedence over allow rules. + * + * @generated from field: repeated openshell.sandbox.v1.L7DenyRule deny_rules = 10; + */ + denyRules: L7DenyRule[]; + + /** + * When true, percent-encoded '/' (%2F) is preserved in path segments + * rather than rejected by the L7 path canonicalizer. Required for + * upstreams like GitLab that embed %2F in namespaced resource paths. + * Defaults to false (strict). + * + * @generated from field: bool allow_encoded_slash = 11; + */ + allowEncodedSlash: boolean; + + /** + * GraphQL persisted-query behavior for hash-only/saved-query requests: + * "deny" (default) or "allow_registered". + * + * @generated from field: string persisted_queries = 12; + */ + persistedQueries: string; + + /** + * Trusted GraphQL persisted-query registry keyed by hash or service-specific ID. + * Only used when persisted_queries is "allow_registered". + * + * @generated from field: map graphql_persisted_queries = 13; + */ + graphqlPersistedQueries: { [key: string]: GraphqlOperation }; + + /** + * Maximum GraphQL request body bytes to buffer for inspection. + * Defaults to 65536 when unset. + * + * @generated from field: uint32 graphql_max_body_bytes = 14; + */ + graphqlMaxBodyBytes: number; + + /** + * Optional HTTP path glob that scopes this L7 endpoint on shared host:port APIs. + * Example: use path "/graphql" for protocol "graphql" and "/repos/**" for + * protocol "rest" when both surfaces live under api.example.com:443. + * Empty means all paths. + * + * @generated from field: string path = 15; + */ + path: string; + + /** + * When true on a "rest" endpoint, OpenShell rewrites credential placeholders + * inside client-to-server WebSocket text messages after an allowed HTTP 101 + * upgrade. Defaults to false. + * + * @generated from field: bool websocket_credential_rewrite = 16; + */ + websocketCredentialRewrite: boolean; + + /** + * When true on a "rest" endpoint, OpenShell rewrites credential placeholders + * inside supported textual HTTP request bodies before forwarding upstream. + * Defaults to false. + * + * @generated from field: bool request_body_credential_rewrite = 17; + */ + requestBodyCredentialRewrite: boolean; + + /** + * Internal provenance marker for policy-advisor generated endpoints. + * Advisor-proposed endpoints must not satisfy exact-host SSRF trust unless + * they are converted through an explicit user-authored policy path. + * + * @generated from field: bool advisor_proposed = 18; + */ + advisorProposed: boolean; + + /** + * Proxy-side credential signing mode: "sigv4" for AWS SigV4 re-signing. + * When set, the proxy strips the client's Authorization header and computes + * a fresh SigV4 signature using real credentials from the provider. + * + * @generated from field: string credential_signing = 19; + */ + credentialSigning: string; + + /** + * AWS signing service name override. Required when credential_signing is + * "sigv4" — e.g. "bedrock" for bedrock-runtime endpoints. + * + * @generated from field: string signing_service = 20; + */ + signingService: string; + + /** + * AWS region override for SigV4 signing. When set, takes precedence over + * hostname-based region extraction. Required for non-standard endpoints. + * + * @generated from field: string signing_region = 21; + */ + signingRegion: string; + + /** + * Maximum JSON-RPC-over-HTTP request body bytes to buffer for inspection. + * Defaults to 65536 when unset. + * + * @generated from field: uint32 json_rpc_max_body_bytes = 22; + */ + jsonRpcMaxBodyBytes: number; + + /** + * MCP-only policy and inspection options. Only used when protocol is "mcp". + * + * @generated from field: openshell.sandbox.v1.McpOptions mcp = 23; + */ + mcp?: McpOptions | undefined; + + /** + * Explicit binding authority for static credentials from an attached + * endpointless provider profile. Profiles that already define endpoints + * continue to use those profile endpoints as their credential boundary. + * + * @generated from field: openshell.sandbox.v1.NetworkCredentialBinding credential_binding = 24; + */ + credentialBinding?: NetworkCredentialBinding | undefined; + + /** + * Explicitly permits credential-bearing traffic to use paths that OpenShell + * cannot inspect or rewrite. Defaults to false. This is a security-sensitive + * escape hatch and must be explicitly approved. + * + * @generated from field: bool allow_uninspected_credentials = 25; + */ + allowUninspectedCredentials: boolean; + + /** + * Internal gateway-derived marker indicating that this endpoint belongs to + * an attached credentialed provider. User-authored values are ignored. + * + * @generated from field: bool provider_credentialed = 26; + */ + providerCredentialed: boolean; + + /** + * Internal gateway-derived identity of this endpoint's token-grant authority. + * It binds the provider record and complete profile policy, or the active + * global policy, to this endpoint. User-authored values are ignored. + * + * @generated from field: string token_grant_owner = 27; + */ + tokenGrantOwner: string; +}; + +/** + * Describes the message openshell.sandbox.v1.NetworkEndpoint. + * Use `create(NetworkEndpointSchema)` to create a new message. + */ +export const NetworkEndpointSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_sandbox, 8); + +/** + * MCP options are grouped so MCP-specific policy can grow without adding more + * top-level NetworkEndpoint fields. OpenShell owns the supported revision + * profiles instead of treating dependency enums as the policy contract. + * + * Sources: + * - https://modelcontextprotocol.io/specification/2025-03-26/basic/transports + * - https://modelcontextprotocol.io/specification/2025-06-18/basic/transports + * - https://modelcontextprotocol.io/specification/2025-11-25/basic/transports + * + * @generated from message openshell.sandbox.v1.McpOptions + */ +export type McpOptions = Message<"openshell.sandbox.v1.McpOptions"> & { + /** + * Hardening boundary for tools/call params.name. When unset or true, the + * supervisor enforces the MCP recommended tool-name syntax + * ^[A-Za-z0-9_.-]{1,128}$ before policy evaluation. Set false only for + * compatibility with servers that intentionally use non-recommended names. + * + * Source: + * - https://modelcontextprotocol.io/specification/2025-11-25/server/tools#tool-names + * + * @generated from field: optional bool strict_tool_names = 1; + */ + strictToolNames?: boolean | undefined; + + /** + * Method-layer default for MCP endpoints. When true, OpenShell allows parsed + * MCP-family methods at the method layer unless a tool-name policy narrows + * tools/call. When unset or false, explicit method rules are required. + * + * @generated from field: optional bool allow_all_known_mcp_methods = 2; + */ + allowAllKnownMcpMethods?: boolean | undefined; + + /** + * Exact MCP protocol revisions accepted by the endpoint's policy schema. + * Authors may omit this field. Because proto3 repeated fields do not retain + * presence, omission reaches protobuf ingress as an empty list. Checked + * normalization materializes OpenShell's pinned default revision + * "2025-11-25" before producing canonical downstream state, which is always + * nonempty. + * + * An explicit nonempty list remains an exact allowlist. Duplicates, moving + * aliases such as "draft" and "latest", and unknown dates are invalid. + * Normalization stores valid values in canonical semantic order. These + * values identify core revisions; they do not enable separate SEP overlays + * or select runtime parsing and forwarding behavior. + * + * @generated from field: repeated string versions = 3; + */ + versions: string[]; +}; + +/** + * Describes the message openshell.sandbox.v1.McpOptions. + * Use `create(McpOptionsSchema)` to create a new message. + */ +export const McpOptionsSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_sandbox, 9); + +/** + * Trusted GraphQL operation classification. + * + * @generated from message openshell.sandbox.v1.GraphqlOperation + */ +export type GraphqlOperation = Message<"openshell.sandbox.v1.GraphqlOperation"> & { + /** + * Operation type: "query", "mutation", or "subscription". + * + * @generated from field: string operation_type = 1; + */ + operationType: string; + + /** + * Operation name, if known. + * + * @generated from field: string operation_name = 2; + */ + operationName: string; + + /** + * Root field names selected by the operation. + * + * @generated from field: repeated string fields = 3; + */ + fields: string[]; +}; + +/** + * Describes the message openshell.sandbox.v1.GraphqlOperation. + * Use `create(GraphqlOperationSchema)` to create a new message. + */ +export const GraphqlOperationSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_sandbox, 10); + +/** + * An L7 deny rule that blocks specific requests. + * Mirrors L7Allow — same fields, same matching semantics, inverted effect. + * Deny rules are evaluated after allow rules and take precedence. + * + * @generated from message openshell.sandbox.v1.L7DenyRule + */ +export type L7DenyRule = Message<"openshell.sandbox.v1.L7DenyRule"> & { + /** + * Protocol method: HTTP method (REST/WebSocket), JSON-RPC method name, or + * "*" for any when supported by the protocol. + * + * @generated from field: string method = 1; + */ + method: string; + + /** + * URL path glob pattern (REST): "/repos/*\/pulls/*\/reviews", "**" for any. + * + * @generated from field: string path = 2; + */ + path: string; + + /** + * SQL command (SQL): SELECT, INSERT, etc. or "*" for any. + * + * @generated from field: string command = 3; + */ + command: string; + + /** + * Query parameter matcher map (REST). + * Same semantics as L7Allow.query. + * + * @generated from field: map query = 4; + */ + query: { [key: string]: L7QueryMatcher }; + + /** + * GraphQL operation type: "query", "mutation", "subscription", or "*" for any. + * + * @generated from field: string operation_type = 5; + */ + operationType: string; + + /** + * GraphQL operation name glob. "*" matches any operation name. + * + * @generated from field: string operation_name = 6; + */ + operationName: string; + + /** + * GraphQL root field globs. Deny rules match when any selected root field + * matches any configured glob. + * + * @generated from field: repeated string fields = 7; + */ + fields: string[]; + + /** + * MCP params matcher map. Currently only params.name is supported for + * tools/call filtering. Generic protocol "json-rpc" rejects params matchers. + * + * @generated from field: map params = 9; + */ + params: { [key: string]: L7QueryMatcher }; +}; + +/** + * Describes the message openshell.sandbox.v1.L7DenyRule. + * Use `create(L7DenyRuleSchema)` to create a new message. + */ +export const L7DenyRuleSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_sandbox, 11); + +/** + * An L7 policy rule (allow-only). + * + * @generated from message openshell.sandbox.v1.L7Rule + */ +export type L7Rule = Message<"openshell.sandbox.v1.L7Rule"> & { + /** + * @generated from field: openshell.sandbox.v1.L7Allow allow = 1; + */ + allow?: L7Allow | undefined; +}; + +/** + * Describes the message openshell.sandbox.v1.L7Rule. + * Use `create(L7RuleSchema)` to create a new message. + */ +export const L7RuleSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_sandbox, 12); + +/** + * Allowed action definition for L7 rules. + * + * @generated from message openshell.sandbox.v1.L7Allow + */ +export type L7Allow = Message<"openshell.sandbox.v1.L7Allow"> & { + /** + * Protocol method: HTTP method (REST/WebSocket), JSON-RPC method name, or + * "*" for any when supported by the protocol. + * + * @generated from field: string method = 1; + */ + method: string; + + /** + * URL path glob pattern (REST): "/repos/**", "**" for any. + * + * @generated from field: string path = 2; + */ + path: string; + + /** + * SQL command (SQL): SELECT, INSERT, etc. or "*" for any. + * + * @generated from field: string command = 3; + */ + command: string; + + /** + * Query parameter matcher map (REST). + * Key is the decoded query parameter name (case-sensitive). + * Value supports either a single glob (`glob`) or a list (`any`). + * + * @generated from field: map query = 4; + */ + query: { [key: string]: L7QueryMatcher }; + + /** + * GraphQL operation type: "query", "mutation", "subscription", or "*" for any. + * + * @generated from field: string operation_type = 5; + */ + operationType: string; + + /** + * GraphQL operation name glob. "*" matches any operation name. + * + * @generated from field: string operation_name = 6; + */ + operationName: string; + + /** + * GraphQL root field globs. Allow rules match only when every selected root + * field matches one of the configured globs. Omit to match all fields. + * + * @generated from field: repeated string fields = 7; + */ + fields: string[]; + + /** + * MCP params matcher map. Currently only params.name is supported for + * tools/call filtering. Generic protocol "json-rpc" rejects params matchers. + * + * @generated from field: map params = 9; + */ + params: { [key: string]: L7QueryMatcher }; +}; + +/** + * Describes the message openshell.sandbox.v1.L7Allow. + * Use `create(L7AllowSchema)` to create a new message. + */ +export const L7AllowSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_sandbox, 13); + +/** + * Query value matcher for one query parameter key. + * + * @generated from message openshell.sandbox.v1.L7QueryMatcher + */ +export type L7QueryMatcher = Message<"openshell.sandbox.v1.L7QueryMatcher"> & { + /** + * Single glob pattern. + * + * @generated from field: string glob = 1; + */ + glob: string; + + /** + * Any-of glob patterns. + * + * @generated from field: repeated string any = 2; + */ + any: string[]; +}; + +/** + * Describes the message openshell.sandbox.v1.L7QueryMatcher. + * Use `create(L7QueryMatcherSchema)` to create a new message. + */ +export const L7QueryMatcherSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_sandbox, 14); + +/** + * A binary identity for network policy matching. + * + * @generated from message openshell.sandbox.v1.NetworkBinary + */ +export type NetworkBinary = Message<"openshell.sandbox.v1.NetworkBinary"> & { + /** + * @generated from field: string path = 1; + */ + path: string; +}; + +/** + * Describes the message openshell.sandbox.v1.NetworkBinary. + * Use `create(NetworkBinarySchema)` to create a new message. + */ +export const NetworkBinarySchema: GenMessage = /*@__PURE__*/ + messageDesc(file_sandbox, 15); + +/** + * Request to get sandbox settings by sandbox name. + * + * @generated from message openshell.sandbox.v1.GetSandboxConfigRequest + */ +export type GetSandboxConfigRequest = Message<"openshell.sandbox.v1.GetSandboxConfigRequest"> & { + /** + * Workspace scope. Select one named workspace; authenticated sandbox callers may omit it during bootstrap. + * + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 3; + */ + workspaceScope?: WorkspaceSelector | undefined; + + /** + * @generated from field: string name = 1; + */ + name: string; +}; + +/** + * Describes the message openshell.sandbox.v1.GetSandboxConfigRequest. + * Use `create(GetSandboxConfigRequestSchema)` to create a new message. + */ +export const GetSandboxConfigRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_sandbox, 16); + +/** + * Request to get gateway-global settings. + * + * @generated from message openshell.sandbox.v1.GetGatewayConfigRequest + */ +export type GetGatewayConfigRequest = Message<"openshell.sandbox.v1.GetGatewayConfigRequest"> & { +}; + +/** + * Describes the message openshell.sandbox.v1.GetGatewayConfigRequest. + * Use `create(GetGatewayConfigRequestSchema)` to create a new message. + */ +export const GetGatewayConfigRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_sandbox, 17); + +/** + * Response containing gateway-global settings. + * + * @generated from message openshell.sandbox.v1.GetGatewayConfigResponse + */ +export type GetGatewayConfigResponse = Message<"openshell.sandbox.v1.GetGatewayConfigResponse"> & { + /** + * Gateway-global settings map excluding the reserved policy key. + * Registered keys without a configured value are returned with an empty SettingValue. + * + * @generated from field: map settings = 1; + */ + settings: { [key: string]: SettingValue }; + + /** + * Monotonically increasing revision for gateway-global settings. + * + * @generated from field: uint64 settings_revision = 2; + */ + settingsRevision: bigint; +}; + +/** + * Describes the message openshell.sandbox.v1.GetGatewayConfigResponse. + * Use `create(GetGatewayConfigResponseSchema)` to create a new message. + */ +export const GetGatewayConfigResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_sandbox, 18); + +/** + * Type-aware setting value for sandbox/gateway settings. + * + * @generated from message openshell.sandbox.v1.SettingValue + */ +export type SettingValue = Message<"openshell.sandbox.v1.SettingValue"> & { + /** + * @generated from oneof openshell.sandbox.v1.SettingValue.value + */ + value: { + /** + * @generated from field: string string_value = 1; + */ + value: string; + case: "stringValue"; + } | { + /** + * @generated from field: bool bool_value = 2; + */ + value: boolean; + case: "boolValue"; + } | { + /** + * @generated from field: int64 int_value = 3; + */ + value: bigint; + case: "intValue"; + } | { + /** + * @generated from field: bytes bytes_value = 4; + */ + value: Uint8Array; + case: "bytesValue"; + } | { case: undefined; value?: undefined }; +}; + +/** + * Describes the message openshell.sandbox.v1.SettingValue. + * Use `create(SettingValueSchema)` to create a new message. + */ +export const SettingValueSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_sandbox, 19); + +/** + * Effective setting value and the scope it was resolved from. + * + * @generated from message openshell.sandbox.v1.EffectiveSetting + */ +export type EffectiveSetting = Message<"openshell.sandbox.v1.EffectiveSetting"> & { + /** + * @generated from field: openshell.sandbox.v1.SettingValue value = 1; + */ + value?: SettingValue | undefined; + + /** + * @generated from field: openshell.sandbox.v1.SettingScope scope = 2; + */ + scope: SettingScope; +}; + +/** + * Describes the message openshell.sandbox.v1.EffectiveSetting. + * Use `create(EffectiveSettingSchema)` to create a new message. + */ +export const EffectiveSettingSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_sandbox, 20); + +/** + * Complete effective sandbox configuration delivered to a supervisor. Fields + * have the same meaning as the identically numbered GetSandboxConfigResponse + * fields, including fail-closed handling of an unknown + * policy_validation_failure_mode and treating absent configuration_admitted as + * not admitted. Move those field comments here when the polling RPC is removed. + * + * @generated from message openshell.sandbox.v1.SandboxConfigSnapshot + */ +export type SandboxConfigSnapshot = Message<"openshell.sandbox.v1.SandboxConfigSnapshot"> & { + /** + * @generated from field: openshell.sandbox.v1.SandboxPolicy policy = 1; + */ + policy?: SandboxPolicy | undefined; + + /** + * @generated from field: uint32 version = 2; + */ + version: number; + + /** + * @generated from field: string policy_hash = 3; + */ + policyHash: string; + + /** + * @generated from field: map settings = 4; + */ + settings: { [key: string]: EffectiveSetting }; + + /** + * @generated from field: uint64 config_revision = 5; + */ + configRevision: bigint; + + /** + * @generated from field: openshell.sandbox.v1.PolicySource policy_source = 6; + */ + policySource: PolicySource; + + /** + * @generated from field: uint32 global_policy_version = 7; + */ + globalPolicyVersion: number; + + /** + * @generated from field: uint64 provider_env_revision = 8; + */ + providerEnvRevision: bigint; + + /** + * @generated from field: repeated openshell.sandbox.v1.SupervisorMiddlewareService supervisor_middleware_services = 9; + */ + supervisorMiddlewareServices: SupervisorMiddlewareService[]; + + /** + * @generated from field: string workspace = 10; + */ + workspace: string; + + /** + * @generated from field: string policy_validation_failure_mode = 11; + */ + policyValidationFailureMode: string; + + /** + * @generated from field: bool extension_authentication_enabled = 12; + */ + extensionAuthenticationEnabled: boolean; + + /** + * @generated from field: bool configuration_admitted = 13; + */ + configurationAdmitted: boolean; + + /** + * @generated from field: string provider_attachment_epoch = 14; + */ + providerAttachmentEpoch: string; + + /** + * @generated from field: string configuration_instance_id = 15; + */ + configurationInstanceId: string; + + /** + * @generated from field: string configuration_error = 16; + */ + configurationError: string; + + /** + * @generated from field: uint64 settings_revision = 17; + */ + settingsRevision: bigint; + + /** + * Explicit application ingress allowlist. Absent means no app routes. + * + * @generated from field: repeated openshell.sandbox.v1.SandboxServiceRoute service_routes = 18; + */ + serviceRoutes: SandboxServiceRoute[]; +}; + +/** + * Describes the message openshell.sandbox.v1.SandboxConfigSnapshot. + * Use `create(SandboxConfigSnapshotSchema)` to create a new message. + */ +export const SandboxConfigSnapshotSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_sandbox, 21); + +/** + * Response containing effective sandbox settings and policy, projected from + * the SandboxConfigSnapshot that push supervisors receive. + * + * @generated from message openshell.sandbox.v1.GetSandboxConfigResponse + */ +export type GetSandboxConfigResponse = Message<"openshell.sandbox.v1.GetSandboxConfigResponse"> & { + /** + * The sandbox policy configuration. + * + * @generated from field: openshell.sandbox.v1.SandboxPolicy policy = 1; + */ + policy?: SandboxPolicy | undefined; + + /** + * Current policy version (monotonically increasing per sandbox). + * + * @generated from field: uint32 version = 2; + */ + version: number; + + /** + * SHA-256 hash of the serialized policy payload. + * + * @generated from field: string policy_hash = 3; + */ + policyHash: string; + + /** + * Effective settings resolved for this sandbox, excluding the reserved policy key. + * Registered keys without a configured value are returned with an empty EffectiveSetting.value. + * + * @generated from field: map settings = 4; + */ + settings: { [key: string]: EffectiveSetting }; + + /** + * Fingerprint for effective config (policy + settings). Changes when any effective input changes. + * + * @generated from field: uint64 config_revision = 5; + */ + configRevision: bigint; + + /** + * Source of the policy payload for this response. + * + * @generated from field: openshell.sandbox.v1.PolicySource policy_source = 6; + */ + policySource: PolicySource; + + /** + * When policy_source is GLOBAL, the version of the global policy revision. + * Zero when no global policy is active or when policy_source is SANDBOX. + * + * @generated from field: uint32 global_policy_version = 7; + */ + globalPolicyVersion: number; + + /** + * Fingerprint for provider credential inputs attached to this sandbox. + * Changes when attached provider names or attached provider records change. + * + * @generated from field: uint64 provider_env_revision = 8; + */ + providerEnvRevision: bigint; + + /** + * Operator-registered supervisor middleware services required by the + * effective policy. Built-in middleware is not included. + * + * @generated from field: repeated openshell.sandbox.v1.SupervisorMiddlewareService supervisor_middleware_services = 9; + */ + supervisorMiddlewareServices: SupervisorMiddlewareService[]; + + /** + * Workspace the sandbox belongs to. Allows the supervisor to learn its + * workspace context for subsequent workspace-scoped RPCs. + * + * @generated from field: string workspace = 10; + */ + workspace: string; + + /** + * Gateway-configured posture for rejected policy generations. Valid values + * are "fail_closed" and "retain_last_valid". Unknown or empty values must + * be treated as fail_closed by the supervisor. + * + * @generated from field: string policy_validation_failure_mode = 11; + */ + policyValidationFailureMode: string; + + /** + * Whether this gateway can mint authenticated extension credentials. + * False also covers older gateways that do not advertise this capability; + * supervisors preserve their legacy unauthenticated connection behavior. + * + * @generated from field: bool extension_authentication_enabled = 12; + */ + extensionAuthenticationEnabled: boolean; + + /** + * Gateway-owned attachment identity captured with this desired configuration. + * Compare for equality; reattachment invalidates previous installation evidence. + * + * @generated from field: string provider_attachment_epoch = 14; + */ + providerAttachmentEpoch: string; + + /** + * True only after validating this complete policy/provider composition. + * Missing (older gateway) is deliberately not admission. + * + * @generated from field: bool configuration_admitted = 13; + */ + configurationAdmitted: boolean; + + /** + * Bounded, credential-free admission diagnostic. Empty for admitted policy. + * + * @generated from field: string configuration_error = 16; + */ + configurationError: string; + + /** + * Registration fence for a new supervisor; capture once and retain on retry. + * + * @generated from field: string configuration_instance_id = 15; + */ + configurationInstanceId: string; + + /** + * Monotonic revision of the sandbox-scoped settings row. + * + * @generated from field: uint64 settings_revision = 17; + */ + settingsRevision: bigint; + + /** + * @generated from field: repeated openshell.sandbox.v1.SandboxServiceRoute service_routes = 18; + */ + serviceRoutes: SandboxServiceRoute[]; +}; + +/** + * Describes the message openshell.sandbox.v1.GetSandboxConfigResponse. + * Use `create(GetSandboxConfigResponseSchema)` to create a new message. + */ +export const GetSandboxConfigResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_sandbox, 22); + +/** + * Gateway-declared service installed by a supervisor; this does not grant + * access to arbitrary workload ports or assert application health. + * + * @generated from message openshell.sandbox.v1.SandboxServiceRoute + */ +export type SandboxServiceRoute = Message<"openshell.sandbox.v1.SandboxServiceRoute"> & { + /** + * @generated from field: string endpoint_id = 1; + */ + endpointId: string; + + /** + * @generated from field: string name = 2; + */ + name: string; + + /** + * @generated from field: uint32 target_port = 3; + */ + targetPort: number; + + /** + * @generated from field: int32 authorization_mode = 4; + */ + authorizationMode: number; + + /** + * @generated from field: uint64 resource_version = 5; + */ + resourceVersion: bigint; +}; + +/** + * Describes the message openshell.sandbox.v1.SandboxServiceRoute. + * Use `create(SandboxServiceRouteSchema)` to create a new message. + */ +export const SandboxServiceRouteSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_sandbox, 23); + +/** + * Connection details for one operator-registered supervisor middleware service. + * V1 supports plaintext and server-authenticated TLS gRPC. + * + * @generated from message openshell.sandbox.v1.SupervisorMiddlewareService + */ +export type SupervisorMiddlewareService = Message<"openshell.sandbox.v1.SupervisorMiddlewareService"> & { + /** + * Operator-owned registration name used by policy attachments and diagnostics. + * + * @generated from field: string name = 1; + */ + name: string; + + /** + * gRPC endpoint reachable from the sandbox supervisor. + * + * @generated from field: string grpc_endpoint = 2; + */ + grpcEndpoint: string; + + /** + * Operator-owned logical payload limit applied to every binding exposed by + * the service. This caps HTTP bodies and complete WebSocket messages. + * + * @generated from field: uint64 max_payload_bytes = 3; + */ + maxPayloadBytes: bigint; + + /** + * Default RPC timeout for this service. Absence uses the platform default of + * 500ms. Values must be between 10ms and 30s. + * + * @generated from field: google.protobuf.Duration request_timeout = 104; + */ + requestTimeout?: Duration | undefined; + + /** + * PEM-encoded trust roots loaded by the gateway from the operator-configured + * tls_ca_cert_path. Empty uses the platform trust store. + * + * @generated from field: bytes tls_ca_cert_pem = 5; + */ + tlsCaCertPem: Uint8Array; + + /** + * Exact JWT audience for this service. The gateway resolves an omitted + * operator value to a kind-scoped audience derived from the registration + * name before sending sandbox config. + * + * @generated from field: string audience = 6; + */ + audience: string; + + /** + * Operator opt-out from extension authentication for this registration. + * When true the service may use a plaintext endpoint and OpenShell attaches + * no bearer credential; supervisors must not request one. Intended only for + * trusted-network development deployments. + * + * @generated from field: bool allow_insecure_transport = 7; + */ + allowInsecureTransport: boolean; + + /** + * How the gateway and supervisor authorize the bindings returned by Describe. + * Absence preserves dynamic discovery. A supervisor predating this field + * cannot enforce a binding policy; upgrade supervisors before requiring one. + * + * @generated from field: openshell.sandbox.v1.SupervisorMiddlewareBindingPolicy binding_policy = 8; + */ + bindingPolicy: SupervisorMiddlewareBindingPolicy; + + /** + * Operation/phase pairs required by an allowlist or exact policy. Every + * listed binding must be advertised, and only listed bindings may run. + * + * @generated from field: repeated openshell.sandbox.v1.SupervisorMiddlewareBinding bindings = 9; + */ + bindings: SupervisorMiddlewareBinding[]; +}; + +/** + * Describes the message openshell.sandbox.v1.SupervisorMiddlewareService. + * Use `create(SupervisorMiddlewareServiceSchema)` to create a new message. + */ +export const SupervisorMiddlewareServiceSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_sandbox, 24); + +/** + * TLS handling for a network endpoint. + * + * @generated from enum openshell.sandbox.v1.NetworkTlsMode + */ +export enum NetworkTlsMode { + /** + * Auto-detect TLS and terminate it when inspection is configured. + * + * @generated from enum value: NETWORK_TLS_MODE_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * Disable TLS detection and relay the connection without inspection. + * + * @generated from enum value: NETWORK_TLS_MODE_SKIP = 1; + */ + SKIP = 1, + + /** + * Rejected by policy validation; use NETWORK_TLS_MODE_UNSPECIFIED. + * + * @generated from enum value: NETWORK_TLS_MODE_TERMINATE = 2 [deprecated = true]; + * @deprecated + */ + TERMINATE = 2, + + /** + * Rejected by policy validation; use NETWORK_TLS_MODE_UNSPECIFIED. + * + * @generated from enum value: NETWORK_TLS_MODE_PASSTHROUGH = 3 [deprecated = true]; + * @deprecated + */ + PASSTHROUGH = 3, +} + +/** + * Describes the enum openshell.sandbox.v1.NetworkTlsMode. + */ +export const NetworkTlsModeSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_sandbox, 0); + +/** + * Enforcement behavior for inspected network traffic. + * + * @generated from enum openshell.sandbox.v1.NetworkEnforcementMode + */ +export enum NetworkEnforcementMode { + /** + * Preserve the existing default: log violations and allow traffic. + * + * @generated from enum value: NETWORK_ENFORCEMENT_MODE_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * Deny traffic that does not satisfy the endpoint policy. + * + * @generated from enum value: NETWORK_ENFORCEMENT_MODE_ENFORCE = 1; + */ + ENFORCE = 1, + + /** + * Log policy violations and allow the traffic. + * + * @generated from enum value: NETWORK_ENFORCEMENT_MODE_AUDIT = 2; + */ + AUDIT = 2, +} + +/** + * Describes the enum openshell.sandbox.v1.NetworkEnforcementMode. + */ +export const NetworkEnforcementModeSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_sandbox, 1); + +/** + * Shorthand access policy for an inspected network endpoint. + * + * @generated from enum openshell.sandbox.v1.NetworkAccessPreset + */ +export enum NetworkAccessPreset { + /** + * No access preset; explicit rules may define allowed traffic. + * + * @generated from enum value: NETWORK_ACCESS_PRESET_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * Allow read-only operations for the selected protocol. + * + * @generated from enum value: NETWORK_ACCESS_PRESET_READ_ONLY = 1; + */ + READ_ONLY = 1, + + /** + * Allow read and write operations for the selected protocol. + * + * @generated from enum value: NETWORK_ACCESS_PRESET_READ_WRITE = 2; + */ + READ_WRITE = 2, + + /** + * Allow every operation supported by the selected protocol. + * + * @generated from enum value: NETWORK_ACCESS_PRESET_FULL = 3; + */ + FULL = 3, +} + +/** + * Describes the enum openshell.sandbox.v1.NetworkAccessPreset. + */ +export const NetworkAccessPresetSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_sandbox, 2); + +/** + * Scope that currently controls a setting. + * + * @generated from enum openshell.sandbox.v1.SettingScope + */ +export enum SettingScope { + /** + * @generated from enum value: SETTING_SCOPE_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: SETTING_SCOPE_SANDBOX = 1; + */ + SANDBOX = 1, + + /** + * @generated from enum value: SETTING_SCOPE_GLOBAL = 2; + */ + GLOBAL = 2, +} + +/** + * Describes the enum openshell.sandbox.v1.SettingScope. + */ +export const SettingScopeSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_sandbox, 3); + +/** + * Source used for a sandbox configuration payload. + * + * @generated from enum openshell.sandbox.v1.PolicySource + */ +export enum PolicySource { + /** + * @generated from enum value: POLICY_SOURCE_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: POLICY_SOURCE_SANDBOX = 1; + */ + SANDBOX = 1, + + /** + * @generated from enum value: POLICY_SOURCE_GLOBAL = 2; + */ + GLOBAL = 2, +} + +/** + * Describes the enum openshell.sandbox.v1.PolicySource. + */ +export const PolicySourceSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_sandbox, 4); + +/** + * Operator authority over the bindings in a supervisor middleware manifest. + * + * @generated from enum openshell.sandbox.v1.SupervisorMiddlewareBindingPolicy + */ +export enum SupervisorMiddlewareBindingPolicy { + /** + * Older gateways omit this field, which selects dynamic discovery. + * + * @generated from enum value: SUPERVISOR_MIDDLEWARE_BINDING_POLICY_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * Accept all supported bindings in the manifest. + * + * @generated from enum value: SUPERVISOR_MIDDLEWARE_BINDING_POLICY_DYNAMIC = 1; + */ + DYNAMIC = 1, + + /** + * Require and enable the listed bindings; ignore other supported bindings. + * + * @generated from enum value: SUPERVISOR_MIDDLEWARE_BINDING_POLICY_ALLOWLIST = 2; + */ + ALLOWLIST = 2, + + /** + * Require the listed bindings and reject additional bindings. + * + * @generated from enum value: SUPERVISOR_MIDDLEWARE_BINDING_POLICY_EXACT = 3; + */ + EXACT = 3, +} + +/** + * Describes the enum openshell.sandbox.v1.SupervisorMiddlewareBindingPolicy. + */ +export const SupervisorMiddlewareBindingPolicySchema: GenEnum = /*@__PURE__*/ + enumDesc(file_sandbox, 5); + +/** + * An operation/phase pair that the platform can authorize. These identify + * platform capabilities, not service-owned binding names. + * + * @generated from enum openshell.sandbox.v1.SupervisorMiddlewareBinding + */ +export enum SupervisorMiddlewareBinding { + /** + * @generated from enum value: SUPERVISOR_MIDDLEWARE_BINDING_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: SUPERVISOR_MIDDLEWARE_BINDING_HTTP_REQUEST_PRE_CREDENTIALS = 1; + */ + HTTP_REQUEST_PRE_CREDENTIALS = 1, + + /** + * @generated from enum value: SUPERVISOR_MIDDLEWARE_BINDING_HTTP_RESPONSE_PRE_RETURN = 2; + */ + HTTP_RESPONSE_PRE_RETURN = 2, + + /** + * @generated from enum value: SUPERVISOR_MIDDLEWARE_BINDING_WEBSOCKET_MESSAGE_PRE_CREDENTIALS = 3; + */ + WEBSOCKET_MESSAGE_PRE_CREDENTIALS = 3, +} + +/** + * Describes the enum openshell.sandbox.v1.SupervisorMiddlewareBinding. + */ +export const SupervisorMiddlewareBindingSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_sandbox, 6); + From 964b2e7145a376ad9f06227818719d4d934deb8d Mon Sep 17 00:00:00 2001 From: Piotr Mlocek Date: Tue, 10 Nov 2026 17:34:20 -0800 Subject: [PATCH 3/7] test: vendor the OAuth conformance fixture from core src/oidc.test.ts read core's sdk/conformance fixture through a relative path. The copy lives in test/fixtures, and vendored:check compares it with core at the pinned ref. Biome skips it so it stays byte-identical. Signed-off-by: Piotr Mlocek --- biome.json | 2 +- scripts/vendored-core-files.txt | 7 +++ src/oidc.test.ts | 2 +- test/fixtures/oauth-client-credentials.json | 44 +++++++++++++++++++ .../oauth-client-credentials.json.license | 2 + 5 files changed, 55 insertions(+), 2 deletions(-) create mode 100644 scripts/vendored-core-files.txt create mode 100644 test/fixtures/oauth-client-credentials.json create mode 100644 test/fixtures/oauth-client-credentials.json.license diff --git a/biome.json b/biome.json index 434459d..77ffa5f 100644 --- a/biome.json +++ b/biome.json @@ -6,7 +6,7 @@ "useIgnoreFile": true }, "files": { - "includes": ["**", "!src/gen", "!dist", "!coverage"] + "includes": ["**", "!src/gen", "!dist", "!coverage", "!test/fixtures"] }, "formatter": { "enabled": true, diff --git a/scripts/vendored-core-files.txt b/scripts/vendored-core-files.txt new file mode 100644 index 0000000..65eed62 --- /dev/null +++ b/scripts/vendored-core-files.txt @@ -0,0 +1,7 @@ +# SPDX-License-Identifier: Apache-2.0 +# +# Files copied from NVIDIA/OpenShell at the pinned ref, one per line: +# . `mise run vendored:check` fails when a copy +# differs from core. +sdk/conformance/oauth-client-credentials.json test/fixtures/oauth-client-credentials.json +sdk/conformance/oauth-client-credentials.json.license test/fixtures/oauth-client-credentials.json.license diff --git a/src/oidc.test.ts b/src/oidc.test.ts index 88a8ef0..969accb 100644 --- a/src/oidc.test.ts +++ b/src/oidc.test.ts @@ -7,7 +7,7 @@ import { afterEach, describe, expect, it, vi } from 'vitest'; import { clientCredentials } from './oidc.js'; const conformance = JSON.parse( - readFileSync(new URL('../../conformance/oauth-client-credentials.json', import.meta.url), 'utf8'), + readFileSync(new URL('../test/fixtures/oauth-client-credentials.json', import.meta.url), 'utf8'), ) as { request: Record; urls: { allowed: string[]; rejected: string[] }; diff --git a/test/fixtures/oauth-client-credentials.json b/test/fixtures/oauth-client-credentials.json new file mode 100644 index 0000000..f31d0fe --- /dev/null +++ b/test/fixtures/oauth-client-credentials.json @@ -0,0 +1,44 @@ +{ + "request": { + "grant_type": "client_credentials", + "client_id": "service-client", + "client_secret": "conformance-secret", + "scopes": ["sandbox:read", "sandbox:write"], + "scope": "sandbox:read sandbox:write", + "audience": "openshell-gateway", + "forbidden_implicit_scopes": ["openid", "profile", "email"] + }, + "expiry": { + "leeway_seconds": 30, + "valid_expires_in": 120, + "invalid_expires_in": [0, -1, "NaN", null] + }, + "discovery": { + "configured_issuer": "https://issuer.example.com", + "matching_issuer": "https://issuer.example.com/", + "mismatched_issuer": "https://attacker.example.com", + "redirect_statuses": [301, 302, 307, 308] + }, + "limits": { + "max_response_bytes": 1048576 + }, + "urls": { + "allowed": [ + "https://issuer.example.com", + "http://localhost:8080", + "http://127.0.0.1:8080", + "http://127.42.0.1:8080", + "http://[::1]:8080" + ], + "rejected": [ + "http://issuer.example.com", + "https://user@issuer.example.com", + "https://issuer.example.com/#fragment" + ] + }, + "redaction": { + "secret": "conformance-secret", + "supplier_error": "supplier-sensitive-detail", + "provider_body": "provider-sensitive-detail" + } +} diff --git a/test/fixtures/oauth-client-credentials.json.license b/test/fixtures/oauth-client-credentials.json.license new file mode 100644 index 0000000..817df24 --- /dev/null +++ b/test/fixtures/oauth-client-credentials.json.license @@ -0,0 +1,2 @@ +SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +SPDX-License-Identifier: Apache-2.0 From 087440cd408e3a9c1a65da98f0475a92be3b1740 Mon Sep 17 00:00:00 2001 From: Piotr Mlocek Date: Tue, 10 Nov 2026 17:34:20 -0800 Subject: [PATCH 4/7] feat!: publish as @ai-openshell/sdk GitHub Packages ties an npm scope to the owning account, so this repository can't publish @nvidia/openshell-sdk. The package becomes @ai-openshell/sdk, still on GitHub Packages, with npmjs.org to follow under the same name. The entry points and the API are unchanged. prepublishOnly only builds, because the bindings are committed. The README explains the upgrade and the new development tasks. Signed-off-by: Piotr Mlocek --- README.md | 53 +++++++++++++++++++++++----------------- e2e/interactive-exec.mjs | 2 +- package-lock.json | 4 +-- package.json | 12 +++++---- src/client.ts | 4 +-- src/index.ts | 2 +- src/raw.ts | 2 +- 7 files changed, 44 insertions(+), 35 deletions(-) diff --git a/README.md b/README.md index 8b64c97..ae5f6b0 100644 --- a/README.md +++ b/README.md @@ -1,9 +1,11 @@ -# @nvidia/openshell-sdk +# @ai-openshell/sdk TypeScript client for the OpenShell gateway — thin, idiomatic bindings generated from the OpenShell protobufs. Distributed via GitHub Packages. A public npm release under the same name follows once the npm org is in place; the install specifier and API are unchanged across that move. +This package was published from [NVIDIA/OpenShell](https://github.com/NVIDIA/OpenShell) as `@nvidia/openshell-sdk` up to OpenShell `v0.1.8`. To upgrade, replace `@nvidia/openshell-sdk` with `@ai-openshell/sdk` in `package.json` and in imports, and change the `.npmrc` scope below. The entry points (`.` and `./raw`) and the API are unchanged. + Use the SDK and gateway from the same OpenShell release when possible. The raw types and RPC descriptors are generated from the protobuf definitions in that release; curated methods remain compatible while those RPC contracts remain @@ -11,22 +13,22 @@ compatible. ## Install -Published to GitHub Packages, so point the `@nvidia` scope at it with a project `.npmrc`: +Published to GitHub Packages, so point the `@ai-openshell` scope at it with a project `.npmrc`: ```shell -@nvidia:registry=https://npm.pkg.github.com +@ai-openshell:registry=https://npm.pkg.github.com ``` Authenticate with a GitHub token that has `read:packages`, then: ```shell -npm install @nvidia/openshell-sdk +npm install @ai-openshell/sdk ``` ## Usage ```ts -import { OpenShellClient } from '@nvidia/openshell-sdk' +import { OpenShellClient } from '@ai-openshell/sdk' const client = await OpenShellClient.connect({ gateway: 'https://gateway.example.com', @@ -72,7 +74,7 @@ the client's lifetime. For long-running service automation, use the renewable client-credentials provider: ```ts -import { clientCredentials, OpenShellClient } from '@nvidia/openshell-sdk' +import { clientCredentials, OpenShellClient } from '@ai-openshell/sdk' const client = await OpenShellClient.connect({ gateway, @@ -111,7 +113,7 @@ await client.sandbox.create({ directly — same API, one less hop: ```ts -import { SandboxClient } from '@nvidia/openshell-sdk' +import { SandboxClient } from '@ai-openshell/sdk' const sandbox = await SandboxClient.connect({ gateway, oidcToken }) await sandbox.create({ image }) @@ -125,7 +127,7 @@ Enable operator authentication at the gateway and omit OIDC and edge tokens. No sandbox or provider attachment is required. ```ts -import { ProviderClient } from '@nvidia/openshell-sdk' +import { ProviderClient } from '@ai-openshell/sdk' const providers = await ProviderClient.connect({ gateway, caCert, clientCert, clientKey }) const credentials = await providers.getCredentials( @@ -224,7 +226,7 @@ own image, environment, resource, and driver-specific settings; sandbox creation from a template can still attach labels, providers, and create-time policy. ```ts -import { OpenShellClient, type SandboxWorkloadTemplate } from '@nvidia/openshell-sdk' +import { OpenShellClient, type SandboxWorkloadTemplate } from '@ai-openshell/sdk' const client = await OpenShellClient.connect({ gateway, oidcToken }) @@ -285,13 +287,13 @@ Curated methods are added deliberately, so some gateway RPCs are not yet wrapped ### Advanced: raw escape hatch -`client.raw` is a generated client for every gateway RPC, including surface the curated sub-clients do not wrap yet (gateway config, provider CRUD, policy status, watch, logs, and the full observed `Sandbox`). `client.transport` is the shared connection, so extra clients reuse one socket. Generated request and response types live at `@nvidia/openshell-sdk/raw`. +`client.raw` is a generated client for every gateway RPC, including surface the curated sub-clients do not wrap yet (gateway config, provider CRUD, policy status, watch, logs, and the full observed `Sandbox`). `client.transport` is the shared connection, so extra clients reuse one socket. Generated request and response types live at `@ai-openshell/sdk/raw`. ```ts import { create } from '@bufbuild/protobuf' -import { OpenShellClient } from '@nvidia/openshell-sdk' -import { WorkspaceSelectorSchema } from '@nvidia/openshell-sdk/raw' -import type { GetGatewayConfigResponse } from '@nvidia/openshell-sdk/raw' +import { OpenShellClient } from '@ai-openshell/sdk' +import { WorkspaceSelectorSchema } from '@ai-openshell/sdk/raw' +import type { GetGatewayConfigResponse } from '@ai-openshell/sdk/raw' const client = await OpenShellClient.connect({ gateway, oidcToken }) @@ -321,7 +323,7 @@ installs no application routes. Complete object literals typed as either generated message must add `serviceRoutes: []`. Alternatively, use `create(SandboxConfigSnapshotSchema, init)` or `create(GetSandboxConfigResponseSchema, init)` from `@bufbuild/protobuf`, with -the corresponding schema imported from `@nvidia/openshell-sdk/raw`. Schema-based +the corresponding schema imported from `@ai-openshell/sdk/raw`. Schema-based initialization supplies the empty array when omitted. The curated SDK API is unchanged. @@ -335,16 +337,21 @@ The SDK ships primitives, not the CLI's terminal experience. Some things are int ## Development -The version field is a `0.0.0` placeholder; CI stamps the real version from the git release tag at publish time, matching the Rust and Python packages. +The version field is a `0.0.0` placeholder; the release workflow stamps the real version at publish time. + +The bindings in `src/gen/` are generated from the protos of the OpenShell core release pinned in `mise.toml` (`OPENSHELL_CORE_REF`) and committed, so building and testing need no core checkout. `mise run proto:check` fails when they are stale. ```shell -mise run sdk:ts:proto # generate stubs from proto/ with buf -mise run sdk:ts:format # Biome: format + safe fixes (writes) -mise run sdk:ts:lint # Biome: lint + format check (read-only) -mise run sdk:ts:typecheck # tsc --noEmit -mise run sdk:ts:test # Vitest unit tests with an 80% line-coverage gate -mise run sdk:ts:build # emit dist/ -mise run e2e:sdk:ts:exec # public interactive helper against an isolated Docker gateway +mise run ci # everything CI runs: check, test, build +mise run proto:gen # fetch core's protos at the pin and regenerate src/gen/ +mise run format # Biome: format + safe fixes (writes) +mise run check # format check, lint, typecheck, proto:check, vendored:check +mise run test # Vitest unit tests with an 80% line-coverage gate +mise run build # emit dist/ and verify the package contents ``` -Formatting and linting are handled by [Biome](https://biomejs.dev) (`biome.json`): 2-space indent, single quotes, semicolons, 120-column width. Generated `src/gen/` is excluded. `sdk:ts:lint` runs in CI as part of `sdk:ts:ci`. +Formatting and linting are handled by [Biome](https://biomejs.dev) (`biome.json`): 2-space indent, single quotes, semicolons, 120-column width. Generated `src/gen/` and the fixtures vendored from core (`test/fixtures/`, listed in `scripts/vendored-core-files.txt`) are excluded. + +CI runs the unit tests on every Node version in `mise.toml`. To run them on one locally, set `MISE_NODE_VERSION`, for example `MISE_NODE_VERSION=20.20.2 mise run test`. + +`e2e/interactive-exec.mjs` still expects core's Docker gateway harness; running it here against a published gateway comes with the E2E workflow. diff --git a/e2e/interactive-exec.mjs b/e2e/interactive-exec.mjs index eaeb94f..248f53d 100644 --- a/e2e/interactive-exec.mjs +++ b/e2e/interactive-exec.mjs @@ -1,7 +1,7 @@ // SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. // SPDX-License-Identifier: Apache-2.0 -// Run through mise run e2e:sdk:ts:exec, which supplies an isolated gateway. +// Needs a gateway; the E2E workflow that runs it against a published gateway is not set up yet. import assert from 'node:assert/strict'; import { readFileSync } from 'node:fs'; import { join } from 'node:path'; diff --git a/package-lock.json b/package-lock.json index 6c7e890..341c748 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,11 +1,11 @@ { - "name": "@nvidia/openshell-sdk", + "name": "@ai-openshell/sdk", "version": "0.0.0", "lockfileVersion": 3, "requires": true, "packages": { "": { - "name": "@nvidia/openshell-sdk", + "name": "@ai-openshell/sdk", "version": "0.0.0", "license": "Apache-2.0", "dependencies": { diff --git a/package.json b/package.json index ed274cd..0a0f5f9 100644 --- a/package.json +++ b/package.json @@ -1,14 +1,16 @@ { - "name": "@nvidia/openshell-sdk", + "name": "@ai-openshell/sdk", "version": "0.0.0", "description": "Official TypeScript SDK for the OpenShell gateway.", "license": "Apache-2.0", "type": "module", - "homepage": "https://github.com/NVIDIA/OpenShell", + "homepage": "https://github.com/ai-openshell/sdk-typescript", "repository": { "type": "git", - "url": "git+https://github.com/NVIDIA/OpenShell.git", - "directory": "sdk/typescript" + "url": "git+https://github.com/ai-openshell/sdk-typescript.git" + }, + "bugs": { + "url": "https://github.com/ai-openshell/sdk-typescript/issues" }, "publishConfig": { "registry": "https://npm.pkg.github.com" @@ -39,7 +41,7 @@ "format": "biome check --write .", "lint": "biome ci .", "test": "vitest run --coverage", - "prepublishOnly": "npm run gen && npm run build" + "prepublishOnly": "npm run build" }, "dependencies": { "@bufbuild/protobuf": "^2.2.3", diff --git a/src/client.ts b/src/client.ts index 18eeb2f..0b9106c 100644 --- a/src/client.ts +++ b/src/client.ts @@ -1198,7 +1198,7 @@ export class SandboxClient { /** * Advanced escape hatch: a generated client for every gateway RPC, including * surface the curated methods do not wrap yet. Request/response types are the - * generated wire messages (import them from '@nvidia/openshell-sdk/raw'). + * generated wire messages (import them from '@ai-openshell/sdk/raw'). */ readonly raw: Client; /** The shared Connect transport, for building extra clients over the same connection. */ @@ -2147,7 +2147,7 @@ export class OpenShellClient { * Advanced escape hatch: a generated client for every gateway RPC, including * surface the curated sub-clients do not wrap yet (gateway config, provider * CRUD, policy status, watch, logs, and the full observed Sandbox). See - * '@nvidia/openshell-sdk/raw' for the generated request/response types. + * '@ai-openshell/sdk/raw' for the generated request/response types. */ readonly raw: Client; /** The shared Connect transport, for building extra clients over the same connection. */ diff --git a/src/index.ts b/src/index.ts index 4948c13..49f47e4 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1,7 +1,7 @@ // SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. // SPDX-License-Identifier: Apache-2.0 -// Public API surface for @nvidia/openshell-sdk. +// Public API surface for @ai-openshell/sdk. // export type { ConnectOptions, diff --git a/src/raw.ts b/src/raw.ts index 067a655..8c4a9e9 100644 --- a/src/raw.ts +++ b/src/raw.ts @@ -6,7 +6,7 @@ export * from './gen/google/rpc/error_details_pb.js'; // Advanced surface: the full generated protobuf types (messages, enums, and the // OpenShell and SandboxUpdates service descriptors) for callers using the raw escape hatch on // OpenShellClient / SandboxClient (`.raw` and `.transport`). These are the -// uncurated wire types; import them from '@nvidia/openshell-sdk/raw'. The +// uncurated wire types; import them from '@ai-openshell/sdk/raw'. The // curated entry point stays free of generated types so its surface does not // shift when the proto regenerates. The four generated modules export disjoint // symbol names, so a flat re-export is unambiguous. From 8445df7d92b8ddb70b2f90488000624a83b3f5ba Mon Sep 17 00:00:00 2001 From: Piotr Mlocek Date: Tue, 10 Nov 2026 17:34:20 -0800 Subject: [PATCH 5/7] ci: run the checks, the Node test matrix and the build The template's ci workflow: checks, test on every Node version in mise.toml, build, workflows, and the aggregating ci job, which is the one check to require. Signed-off-by: Piotr Mlocek --- .github/workflows/ci.yml | 122 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 122 insertions(+) create mode 100644 .github/workflows/ci.yml diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..51f9833 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,122 @@ +# SPDX-License-Identifier: Apache-2.0 + +# Runs the contract tasks from mise.toml. The `ci` job is the one required +# status check; its name is the same in every repository built from the +# template, so one org ruleset can require it everywhere. +name: ci + +on: + pull_request: + push: + branches: [main] + workflow_dispatch: + +permissions: + contents: read + +concurrency: + group: ci-${{ github.ref }} + cancel-in-progress: ${{ github.event_name == 'pull_request' }} + +jobs: + checks: + name: checks + runs-on: ubuntu-latest + timeout-minutes: 15 + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + + - uses: jdx/mise-action@f5be966e4a917d54244728e6a5fdcd1d93a35e6c # v5.2.6 + with: + install: false + + - name: Install tools + run: mise install --locked + + - name: Format, lint, and drift checks + run: mise run check + + # Every Node version in mise.toml's [tools], which are the releases + # package.json's engines field supports. + test: + name: test (node ${{ matrix.node }}) + runs-on: ubuntu-latest + timeout-minutes: 15 + strategy: + fail-fast: false + matrix: + node: ["20.20.2", "22.23.4", "24.22.2"] + env: + MISE_NODE_VERSION: ${{ matrix.node }} + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + + - uses: jdx/mise-action@f5be966e4a917d54244728e6a5fdcd1d93a35e6c # v5.2.6 + with: + install: false + + - name: Install tools + run: mise install --locked + + - name: Unit tests + run: mise run test + + build: + name: build + runs-on: ubuntu-latest + timeout-minutes: 15 + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + + - uses: jdx/mise-action@f5be966e4a917d54244728e6a5fdcd1d93a35e6c # v5.2.6 + with: + install: false + + - name: Install tools + run: mise install --locked + + - name: Build and verify + run: mise run build + + workflows: + name: workflows + runs-on: ubuntu-latest + timeout-minutes: 10 + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + + - uses: jdx/mise-action@f5be966e4a917d54244728e6a5fdcd1d93a35e6c # v5.2.6 + with: + install: false + + - name: Install tools + run: mise install --locked actionlint shellcheck zizmor + + - name: Lint workflows + run: mise run workflows:check + + ci: + name: ci + if: always() + needs: [checks, test, build, workflows] + runs-on: ubuntu-latest + timeout-minutes: 5 + steps: + - name: Require every job to succeed + env: + RESULTS: ${{ join(needs.*.result, ' ') }} + run: | + for result in $RESULTS; do + if [ "$result" != success ]; then + echo "::error::a required job finished with '$result' ($RESULTS)" + exit 1 + fi + done From 9b7b67d0cc56215beef2a2ed6ac95e099f8de385 Mon Sep 17 00:00:00 2001 From: Piotr Mlocek Date: Tue, 17 Nov 2026 16:48:18 -0800 Subject: [PATCH 6/7] build: pin generated bindings to OpenShell v0.1.9 Signed-off-by: Piotr Mlocek --- mise.toml | 2 +- src/gen/openshell_pb.ts | 217 +++++++++++++++++++++++++++++++++++++++- 2 files changed, 216 insertions(+), 3 deletions(-) diff --git a/mise.toml b/mise.toml index 483fd23..463ca1b 100644 --- a/mise.toml +++ b/mise.toml @@ -28,7 +28,7 @@ zizmor = "1.32.0" [env] # The single core pin: a release tag. -OPENSHELL_CORE_REF = "v0.1.8" +OPENSHELL_CORE_REF = "v0.1.9" # --- Contract tasks --------------------------------------------------------- diff --git a/src/gen/openshell_pb.ts b/src/gen/openshell_pb.ts index 659b416..ad35c61 100644 --- a/src/gen/openshell_pb.ts +++ b/src/gen/openshell_pb.ts @@ -20,7 +20,7 @@ import type { JsonObject, Message } from "@bufbuild/protobuf"; * Describes the file openshell.proto. */ export const file_openshell: GenFile = /*@__PURE__*/ - fileDesc("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", [file_datamodel, file_google_protobuf_duration, file_google_protobuf_struct, file_google_protobuf_timestamp, file_options, file_sandbox]); + fileDesc("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", [file_datamodel, file_google_protobuf_duration, file_google_protobuf_struct, file_google_protobuf_timestamp, file_options, file_sandbox]); /** * IssueSandboxToken request. Empty body; identity is established by the @@ -9973,6 +9973,190 @@ export type SupervisorServiceAdvertisement = Message<"openshell.v1.SupervisorSer export const SupervisorServiceAdvertisementSchema: GenMessage = /*@__PURE__*/ messageDesc(file_openshell, 255); +/** + * One explicit active workspace is required. Omitted and all-workspaces + * selectors are rejected; discovery-only machine grants are separate work. + * + * @generated from message openshell.v1.GetServiceRouteSnapshotRequest + */ +export type GetServiceRouteSnapshotRequest = Message<"openshell.v1.GetServiceRouteSnapshotRequest"> & { + /** + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 1; + */ + workspaceScope?: WorkspaceSelector | undefined; +}; + +/** + * Describes the message openshell.v1.GetServiceRouteSnapshotRequest. + * Use `create(GetServiceRouteSnapshotRequestSchema)` to create a new message. + */ +export const GetServiceRouteSnapshotRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 256); + +/** + * @generated from message openshell.v1.GetServiceRouteSnapshotResponse + */ +export type GetServiceRouteSnapshotResponse = Message<"openshell.v1.GetServiceRouteSnapshotResponse"> & { + /** + * @generated from field: openshell.v1.ServiceRouteSnapshot snapshot = 1; + */ + snapshot?: ServiceRouteSnapshot | undefined; +}; + +/** + * Describes the message openshell.v1.GetServiceRouteSnapshotResponse. + * Use `create(GetServiceRouteSnapshotResponseSchema)` to create a new message. + */ +export const GetServiceRouteSnapshotResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 257); + +/** + * Same workspace authorization as GetServiceRouteSnapshot. A watch sends an + * initial replacement and later replacements, including lease-only renewal. + * Clients reconnect/relist when the bounded stream ends and expire cached + * routes during discovery errors; errors are not empty replacements. + * + * @generated from message openshell.v1.WatchServiceRoutesRequest + */ +export type WatchServiceRoutesRequest = Message<"openshell.v1.WatchServiceRoutesRequest"> & { + /** + * @generated from field: openshell.datamodel.v1.WorkspaceSelector workspace_scope = 1; + */ + workspaceScope?: WorkspaceSelector | undefined; +}; + +/** + * Describes the message openshell.v1.WatchServiceRoutesRequest. + * Use `create(WatchServiceRoutesRequestSchema)` to create a new message. + */ +export const WatchServiceRoutesRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 258); + +/** + * @generated from message openshell.v1.WatchServiceRoutesResponse + */ +export type WatchServiceRoutesResponse = Message<"openshell.v1.WatchServiceRoutesResponse"> & { + /** + * @generated from field: openshell.v1.ServiceRouteSnapshot snapshot = 1; + */ + snapshot?: ServiceRouteSnapshot | undefined; +}; + +/** + * Describes the message openshell.v1.WatchServiceRoutesResponse. + * Use `create(WatchServiceRoutesResponseSchema)` to create a new message. + */ +export const WatchServiceRoutesResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 259); + +/** + * @generated from message openshell.v1.ServiceRouteSnapshot + */ +export type ServiceRouteSnapshot = Message<"openshell.v1.ServiceRouteSnapshot"> & { + /** + * @generated from field: repeated openshell.v1.DiscoveredServiceRoute routes = 1; + */ + routes: DiscoveredServiceRoute[]; + + /** + * Opaque equality token for this complete view, including lease expiries. + * No ordering across replicas or server restarts is implied. + * + * @generated from field: string revision = 2; + */ + revision: string; +}; + +/** + * Describes the message openshell.v1.ServiceRouteSnapshot. + * Use `create(ServiceRouteSnapshotSchema)` to create a new message. + */ +export const ServiceRouteSnapshotSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 260); + +/** + * Trusted supervisor TLS endpoint. Preserve DiscoveredServiceRoute.hostname + * as SNI and HTTP authority; this endpoint never addresses a workload port. + * + * @generated from message openshell.v1.ServiceRouteEndpoint + */ +export type ServiceRouteEndpoint = Message<"openshell.v1.ServiceRouteEndpoint"> & { + /** + * @generated from field: string host = 1; + */ + host: string; + + /** + * @generated from field: uint32 port = 2; + */ + port: number; +}; + +/** + * Describes the message openshell.v1.ServiceRouteEndpoint. + * Use `create(ServiceRouteEndpointSchema)` to create a new message. + */ +export const ServiceRouteEndpointSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 261); + +/** + * Accepted installation evidence, not application health or ingress readiness. + * + * @generated from message openshell.v1.DiscoveredServiceRoute + */ +export type DiscoveredServiceRoute = Message<"openshell.v1.DiscoveredServiceRoute"> & { + /** + * @generated from field: string workspace = 1; + */ + workspace: string; + + /** + * @generated from field: string sandbox = 2; + */ + sandbox: string; + + /** + * Canonical service name; empty identifies the existing unnamed service. + * + * @generated from field: string name = 3; + */ + name: string; + + /** + * @generated from field: string hostname = 4; + */ + hostname: string; + + /** + * @generated from field: openshell.v1.ServiceRouteEndpoint endpoint = 5; + */ + endpoint?: ServiceRouteEndpoint | undefined; + + /** + * Changes on owner/backend/declaration replacement, but not lease renewal. + * + * @generated from field: string installation_version = 6; + */ + installationVersion: string; + + /** + * @generated from field: uint64 declaration_revision = 7; + */ + declarationRevision: bigint; + + /** + * @generated from field: google.protobuf.Timestamp expires_at = 8; + */ + expiresAt?: Timestamp | undefined; +}; + +/** + * Describes the message openshell.v1.DiscoveredServiceRoute. + * Use `create(DiscoveredServiceRouteSchema)` to create a new message. + */ +export const DiscoveredServiceRouteSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_openshell, 262); + /** * @generated from enum openshell.v1.ExtensionKind */ @@ -11901,6 +12085,35 @@ export const OpenShell: GenService<{ }> = /*@__PURE__*/ serviceDesc(file_openshell, 0); +/** + * Application ingress consumers discover routes independently of sandbox management. + * + * @generated from service openshell.v1.ServiceDiscovery + */ +export const ServiceDiscovery: GenService<{ + /** + * Read installed, unexpired application routes in one explicit workspace. + * + * @generated from rpc openshell.v1.ServiceDiscovery.GetServiceRouteSnapshot + */ + getServiceRouteSnapshot: { + methodKind: "unary"; + input: typeof GetServiceRouteSnapshotRequestSchema; + output: typeof GetServiceRouteSnapshotResponseSchema; + }, + /** + * Full replacement views; reauthorize during the bounded watch lifetime. + * + * @generated from rpc openshell.v1.ServiceDiscovery.WatchServiceRoutes + */ + watchServiceRoutes: { + methodKind: "server_streaming"; + input: typeof WatchServiceRoutesRequestSchema; + output: typeof WatchServiceRoutesResponseSchema; + }, +}> = /*@__PURE__*/ + serviceDesc(file_openshell, 1); + /** * Optional sandbox mutations are separate from OpenShell so existing generated * OpenShell server implementations remain source-compatible. @@ -11922,5 +12135,5 @@ export const SandboxUpdates: GenService<{ output: typeof SandboxResponseSchema; }, }> = /*@__PURE__*/ - serviceDesc(file_openshell, 1); + serviceDesc(file_openshell, 2); From 0020123ea6bdaec57a5e02632c662c93e14a488e Mon Sep 17 00:00:00 2001 From: Piotr Mlocek Date: Tue, 17 Nov 2026 16:49:10 -0800 Subject: [PATCH 7/7] docs: describe the SDK move without an outdated release cutoff Signed-off-by: Piotr Mlocek --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index ae5f6b0..af33709 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,7 @@ TypeScript client for the OpenShell gateway — thin, idiomatic bindings generat Distributed via GitHub Packages. A public npm release under the same name follows once the npm org is in place; the install specifier and API are unchanged across that move. -This package was published from [NVIDIA/OpenShell](https://github.com/NVIDIA/OpenShell) as `@nvidia/openshell-sdk` up to OpenShell `v0.1.8`. To upgrade, replace `@nvidia/openshell-sdk` with `@ai-openshell/sdk` in `package.json` and in imports, and change the `.npmrc` scope below. The entry points (`.` and `./raw`) and the API are unchanged. +This package was published from [NVIDIA/OpenShell](https://github.com/NVIDIA/OpenShell) as `@nvidia/openshell-sdk` before SDK development moved to this repository. To upgrade, replace `@nvidia/openshell-sdk` with `@ai-openshell/sdk` in `package.json` and in imports, and change the `.npmrc` scope below. The entry points (`.` and `./raw`) and the API are unchanged. Use the SDK and gateway from the same OpenShell release when possible. The raw types and RPC descriptors are generated from the protobuf definitions in that