Skip to content

[Feature]: Start a Kubernetes workspace without registry access on the client #1731

Closed

Description

@wsmoak

Before submitting

  • I have searched existing feature requests and discussions to confirm this has not been requested

Problem or motivation

devsy workspace up for a devcontainer with a prebuilt image: reads that image's config from the registry on the machine that runs the CLI. On the kubernetes provider the node pulls the image, and in many clusters the cluster already has its own registry credentials (a node role, a service account's imagePullSecrets, or a secret an admin manages). The client still needs read access to the registry, though only for the image config.

The kubernetes provider has no imageBackend, so inspectImage (pkg/devcontainer/inspect.go) calls image.GetImageConfigForArch. Outside a pod, GetKeychain (pkg/image/auth.go) returns authn.DefaultKeychain, which uses the client's Docker credentials. Devsy then uses only five fields: User, Env, Labels (for devcontainer.metadata), Entrypoint and Cmd.

When the client can't read the registry, up fails before anything happens in the cluster:

Error: start workspace: build image: get image build info: failed to get image
config for architecture amd64: retrieve image <registry>/<repo>:<tag>:
GET https://<registry>/v2/<repo>/manifests/<tag>: unexpected status code
401 Unauthorized

Who benefits: teams on shared clusters. People who start workspaces should need little more than access to their own namespace. Today each of them also needs read access to the registry and a docker login on their laptop (renewed every few hours for short-lived cloud registry tokens). That access allows pulling the whole image, which goes beyond the config Devsy actually reads.

Seen on CLI v1.24.0; code read at 61b3c83 (v1.25.0-beta.6).

Proposed solution

Accept the image details from the user, so the CLI doesn't contact the registry for the inspect step. For example, a provider option or flag such as --image-details <file> that takes the JSON of config.ImageDetails. When it is set, inspectImage skips the registry entirely and fails loudly if the file is missing or invalid. The team that builds the image can produce the file in CI next to the image digest.

This is the smallest change, and it stays predictable because the CLI never tries the registry.

For least privilege, pin the image by digest so the image details always match the image the node pulls.

Scope: a prebuilt image: with no features on the kubernetes provider. On this path extendImage returns without building, so the image config is the only thing the client needs from the registry. Features, Dockerfile builds and prebuilds are out of scope. The existing pull-secret path (EnsurePullSecret copying client credentials when kubernetesPullSecretsEnabled is on) stays as it is.

Alternatives considered

  1. Inspect from the cluster (no change for users, but weaker on least privilege). Read the image config inside the cluster and return the five fields to the CLI. As far as I can tell, the kubernetes driver doesn't run a helper pod or job today, so this needs a short-lived pod, RBAC, waiting and cleanup. It could be an imageBackend for the kubernetes driver, which would also cover getImageTag.
    Downside: the helper pod would hold usable registry credentials, and the in-cluster keychain (kubernetesauth.NewInCluster) reads the service account and its imagePullSecrets through the API, so that identity needs get on secrets. Anyone who can create pods in the namespace could then use those credentials. With --image-details, devs need no registry access and no extra RBAC.

  2. Fall back to devcontainer.json alone (opt-in only). When the inspect fails and remoteUser is set, continue with only devcontainer.json values and warn that devcontainer.metadata wasn't merged. Risky as a silent fallback, because missing metadata changes lifecycle behaviour without any visible error.

Workaround today: give users read-only pull access to the repository, plus a registry login on the client.

Area

Providers, Dev containers

Acceptance criteria

  • A Kubernetes workspace with a prebuilt image: (no features) starts when the client has no credentials for the image's registry, as long as the cluster can pull the image.
  • Remote user, env, entrypoint/cmd and devcontainer.metadata labels are applied the same as when the inspect runs on the client.
  • Invalid or missing image details produce a clear error, not a silent fallback.
  • Existing behaviour is unchanged when the option isn't used.
  • Documented in the kubernetes provider docs.

Additional context

Requested upstream in loft-sh/devpod#1888 ("Cannot use a private repo with devpod in kubernetes"), which was closed by the stale bot without a response.

Related: inspectImage first calls TargetArchitecture (pkg/driver/kubernetes/target_architecture.go), which lists every node unless the architecture provider option is set. That also needs a cluster-scoped permission. Setting architecture avoids it today, but it may be worth documenting next to the fix.

Activity

  1. wsmoak commented on Oct 30, 2026

    @wsmoak
    ContributorAuthor

    WIP on branch main...wsmoak:devsy:feat/k8s-image-details

    It is working locally on k8s in Docker Desktop.

  2. wsmoak commented on Oct 30, 2026

    @wsmoak
    ContributorAuthor

    IMAGE_DETAILS comes from the Go type name. IMAGE_CONFIG_FILE would say more clearly what to pass.

  3. skevetter commented on Oct 31, 2026

    @skevetter
    Contributor

    Implementation plan: Kubernetes image configuration supplied by the operator

    Status: still outstanding. The current main branch still inspects the image from the client. A contributor implementation exists on wsmoak:feat/k8s-image-details, reviewed at e20ee457e539eedc43cebd387f5a747cce4f5cb5. No corresponding open or merged PR was found in the issue timeline or searches for this issue and branch. Continue that work on this issue rather than creating a duplicate feature.

    Main baseline: 9bc12ee041ca854c6f81de95fd8c6e49d7cc028c, reviewed 30 October 2026. The requirements below are proposed changes. This investigation inspected source and the contributor branch; it did not execute a Kubernetes reproduction.

    1. Verified path and gaps

    Finding Evidence Required consequence
    Kubernetes supplies a runtime driver but no image backend. drivercreate.New/newImageBackend Keep the runtime/image-backend split. A supplied configuration file is not a new build/push backend.
    getImageBuildInfoFromImage calls inspectImage, which obtains the image configuration from the registry. Outside a pod, the keychain is the client's default Docker keychain. build.go:250-281, inspect.go, auth.go:53-66 Bypass the specific prebuilt-image inspection only when an explicit validated input exists.
    Image metadata is merged through existing code, and the no-feature path returns without a build. extendImage, GetExtendedBuildInfo Feed supplied details into the same metadata/merge/run-options path. Do not reconstruct lifecycle or user precedence in Kubernetes code.
    TargetArchitecture lists cluster nodes unless ARCHITECTURE is configured. Agent binary delivery also calls it. target_architecture.go, setup.go:191-220 Skipping image inspection alone does not establish namespace-only permissions. Define architecture explicitly in this mode.
    Pull-secret forwarding is a separate conditional path. ensurePullSecrets/finalizePodSpec, pullsecrets.go Keep that option's behavior. Cluster-owned image authorization must not be copied back to the client.
    Provider options are compared to decide pod replacement and are serialized into a pod annotation. runPod, optionsEqual A client-local sidecar path must not become a pod identity field or leak into the cluster annotation.

    The contributor branch already makes the useful architectural choice: an optional ImageDetailsDriver capability and a prebuilt-image override in build.go, with IMAGE_CONFIG_FILE wired through provider/options types. Retain that approach.

    Before merging, close these concrete branch gaps:

    • loadImageDetails accepts an arbitrary supplied ID, cannot establish which requested image the file describes, and does not validate OS/architecture. A provider setting reused for another workspace can silently apply the wrong user, environment or metadata.
    • The parser tests “all five fields empty” as invalid. An explicitly present empty OCI configuration is distinguishable from a missing config member and must be handled by structure, not by the truthiness of its values.
    • The hook is used by the image path even when Features are present, while Dockerfile paths do not call it. The branch does not implement the requested narrow scope or a uniform error for unsupported combinations.
    • The current E2E proves that a file-supplied marker is used. It does not prove that the client lacks image-registry access, that no fallback request occurs, or that cluster-owned pull credentials work.
    • The branch is based on beta.6 and is behind current main. Rebase it without removing subsequent provider provenance/icon fields or the merged Kubernetes lifecycle changes.

    2. Product contract and bounded scope

    Use the contributor's clarified name, IMAGE_CONFIG_FILE, as an advanced Kubernetes provider option. Reuse the existing provider-options path in CLI and Desktop; do not add a competing global --image-details flag or a second Desktop launch form.

    The first version supports an explicitly selected, digest-pinned devcontainer.json image: with no Features and no image build. The cluster pulls the image using its existing node credentials, service account or explicitly configured pull-secret references. Devsy uses the supplied file for the five image fields it already consumes: User, Env, Labels, Entrypoint, and Cmd.

    Require ARCHITECTURE to be set for this mode and to match the file. This avoids both inspection-time and agent-delivery node enumeration. On a heterogeneous cluster the operator also uses the existing NODE_SELECTOR/pod template to schedule onto the matching architecture; ARCHITECTURE alone is not a scheduler constraint. Do not introduce an implicit node-selector change as part of this feature.

    Example after implementation, with client credential injection explicitly disabled for the active context:

    devsy context set --option SSH_INJECT_DOCKER_CREDENTIALS=false
    devsy workspace up ./project --provider kubernetes --ide none \
      --provider-option IMAGE_CONFIG_FILE=/absolute/path/project-image.json \
      --provider-option ARCHITECTURE=amd64 \
      --provider-option KUBERNETES_PULL_SECRETS_ENABLED=false

    devsy context set [context-name] --option KEY=VALUE is the existing context command syntax (cmd/context/set_options.go). The first command changes the selected context's forwarding preference; it is not a new per-workspace flag. Configure both SSH_INJECT_DOCKER_CREDENTIALS=false and KUBERNETES_PULL_SECRETS_ENABLED=false for the no-client-credential-read acceptance flow. Disabling Kubernetes pull-secret creation alone does not disable the separate SSH credential-injection service.

    Use an absolute path in the process running the Kubernetes provider. The built-in provider is local, so this is the client machine, including Desktop's local CLI child. Validate absolute Windows paths with the native path API. Do not interpret this as a container path, shell expression, URL, project-relative remote path or Kubernetes Secret name.

    When the option is unset, preserve current inspection, credential, build and error behavior. When it is set, invalid input is a hard configuration error and must never trigger a registry fallback. The guarantee covers Devsy's target-image inspection, feature retrieval and build paths in this supported mode. Kubernetes API calls, agent downloads and networking explicitly requested by a user's lifecycle commands remain separate operations.

    Reject these combinations before image/feature registry access or pod/PVC changes: Dockerfile/build configuration, Compose, attached existing-container sources, nonempty effective Features including CLI-added Features, forced Dockerless, recovery mode, prebuild-repository lookup, build/push/export requests, and standalone workspace build. Existing baked-in Feature metadata in the image remains supported: those Features are already installed and are merged as metadata, not fetched again. Error messages identify the unsupported input and instruct the operator to remove IMAGE_CONFIG_FILE or use a plain prebuilt image.

    Ordinary up on an existing workspace validates the configured sidecar but retains the existing saved runtime configuration and metadata. Editing the sidecar must not silently restart a running pod or reapply image metadata. Explicit recreation adopts new validated details through the normal recreation flow. Missing or invalid sidecars must not prevent status, logs, stop or delete.

    3. Explicit file format and trust boundary

    Adopt one documented version-1 wrapper rather than treating every vaguely similar JSON object as the same format. Reuse config.ImageDetailsConfig for the five-field payload.

    {
      "schemaVersion": 1,
      "image": "registry.example.com/team/project@sha256:<64-hex-digest>",
      "os": "linux",
      "architecture": "amd64",
      "config": {
        "User": "vscode",
        "Env": ["PATH=/usr/local/bin:/usr/bin:/bin", "EXAMPLE=a=b"],
        "Labels": {
          "devcontainer.metadata": "[{\"remoteUser\":\"vscode\"}]"
        },
        "Entrypoint": [],
        "Cmd": []
      }
    }

    The digest above is a placeholder, not a runnable image reference. Optional variant uses the OCI platform convention. The image's build/publish pipeline creates this artifact from the same selected platform image it publishes, then distributes it with that digest. Document a conversion from crane config --platform ... <digest-reference> output to the wrapper; raw OCI configuration lacks the manifest-reference binding and is not accepted directly by this version.

    Validation rules:

    1. Require exactly one JSON object, schema version 1, an explicit non-null config object, a Linux platform and a fully qualified digest-pinned image reference. Reject trailing JSON, arrays, null, unknown wrapper/payload fields and type mismatches. Empty config: {} is structurally valid and preserves existing defaults.
    2. Parse and normalize image references with the existing container-registry reference library. Require the wrapper's repository and digest to equal the selected image:; reject tag-only references. Do not interpret Docker inspect's image/config ID as a manifest reference.
    3. Normalize platform with the existing containerd/platforms dependency; compare the architecture with configured ARCHITECTURE. Reject an unsupported OS or contradictory platform before choosing the agent binary. Document one file per selected platform; a manifest-list digest does not make an amd64 config valid on arm64.
    4. Open a regular file and enforce a 1 MiB byte cap using a bounded reader. Reject a directory, device/FIFO, oversized input, unreadable path and invalid UTF-8. Do not read all bytes before enforcing the cap. Read once per launch attempt and use the same in-memory snapshot for validation and image-build-info construction.
    5. Preserve the complete string values and array ordering. Do not trim values, split Env at every equals sign, expand shell text, or normalize entrypoint/command arguments.
    6. If devcontainer.metadata is present and nonempty, validate its JSON form before calling the existing metadata merge. Accept an object or array of objects, including an empty array; reject malformed JSON or null entries. Current GetImageMetadata can warn and ignore malformed metadata, which is inappropriate for this explicit authoritative input. Keep existing behavior unchanged outside this mode.
    7. Set the returned ImageDetails.ID from the validated requested image reference, not arbitrary file input. Populate OS/architecture/variant and the five Config fields. Use imageBuildInfoFromDetails, GetImageMetadata, GetDevContainerMetadata and MergeConfiguration to retain current user/environment/lifecycle precedence.

    The file is trusted workspace configuration. Its metadata can contain lifecycle commands, privileges, mounts and environment values just as metadata fetched from an image can. Matching the declared digest prevents accidental cross-image use; it does not cryptographically prove that the supplied config bytes belong to that registry image. The publishing pipeline is responsible for producing the correct artifact. Do not claim registry verification without actually performing it. Do not log or upload the raw file.

    4. Exact implementation tasks

    A. Provider contract

    • Retain/add IMAGE_CONFIG_FILE in the Advanced Options group in providers/kubernetes/provider.yaml, with default unset and concise help covering local absolute path, supported prebuilt-image scope, versioned format and matching ARCHITECTURE.
    • Add ImageConfigFile string with json:"imageConfigFile,omitempty" to ProviderKubernetesDriverConfig in pkg/provider/provider.go; resolve it in pkg/options/resolve.go:resolveAgentKubernetesConfig. Preserve unrelated current fields.
    • Keep the provider setting local. Do not copy the input file into workspace content, a pod mount, a Kubernetes Secret or serialized runtime options.
    • In pkg/driver/kubernetes/run.go, strip ImageConfigFile from both operands in optionsEqual. Serialize a copied provider-options value with this field blank in runPod. Do not mutate the live options object. The path alone must not cause pod replacement.
    • Existing provider option persistence may retain the local path. Cross-machine export/import should not pretend the file travelled with the workspace; document that the recipient supplies its own path.

    B. Parser and optional capability

    • Retain the optional ImageDetailsDriver capability in pkg/driver/types.go and the compile-time assertion in pkg/driver/kubernetes/driver.go. Return nil, nil only when the provider option is unset. A configured failure returns an error, never an empty successful fallback.
    • Extend the capability's request to carry the selected image and whether this is a supported image-only launch. Use a small named request struct so the runner owns configuration/operation classification and Kubernetes owns local file parsing. Do not make every runtime implement the new capability.
    • Implement the bounded version-1 loader and validation in pkg/driver/kubernetes/image_details.go or a clearly named replacement image_config.go. Keep file reading, JSON/platform/reference validation and conversion to ImageDetails as focused helpers.
    • Do not load the file in NewKubernetesDriver: that constructor is also used for management operations that must work when the sidecar is gone.
    • Keep all parsed details process-local. Store/reuse a validated result for the current launch attempt; avoid re-reading a changed file between validation and use. Do not introduce a global cache that can leak one workspace's supplied metadata into another.

    C. Runner integration and strict opt-in behavior

    • In pkg/devcontainer/run.go:Up, after effective config/overlay selection is available and before dispatchByConfigKind, invoke the supplied-details preparation helper. It performs the complete scope and file checks for both fresh and existing workspaces. It must run before runSingleContainer starts the agent-prefetch goroutine. User initialization keeps its current ordering; do not claim rollback of user-supplied initializeCommand.
    • In pkg/devcontainer/build.go:getImageBuildInfoFromImage, reuse that validated snapshot for the exact selected image and pass it to imageBuildInfoFromDetails. Call ordinary inspectImage only when the capability says the option was unset.
    • Validate effective Features before feature.GetExtendedBuildInfo can fetch a Feature. Inspect the substituted/overlay/CLI-added configuration, not just the original JSON text.
    • In pkg/devcontainer/prebuild.go:Build, reject configured-file mode before standalone build, prebuild lookup or publication. Reuse the same capability/request semantics instead of reaching into a concrete Kubernetes type from generic runner code.
    • Preserve the existing build-before-delete validation ordering in single.go:buildNewContainerConfig. Invalid input on up --recreate must leave the running pod and PVC untouched.
    • Validate nonempty ARCHITECTURE and file agreement before any TargetArchitecture call from this launch; retain existing target-architecture behavior outside this mode.
    • Keep inspectImage for ordinary Dockerfile bases, intermediate images and other providers. Do not return the supplied details for arbitrary inspection requests.
    • Keep returned metadata/runtime environment on the existing RunOptions/PVC paths, so restart uses the original saved launch recipe. No new background controller, helper pod, secret-reading RBAC or registry-token exchange is required.

    D. Pull credentials and diagnostics

    • Preserve KUBERNETES_PULL_SECRETS_ENABLED and context SSH_INJECT_DOCKER_CREDENTIALS behavior. Document setting both to false for cluster-managed authorization without client Docker credential reads. Use the existing devsy context set [context-name] --option SSH_INJECT_DOCKER_CREDENTIALS=false command for the context setting and the existing provider option for pull-secret creation. Do not silently change an operator's settings when enabling IMAGE_CONFIG_FILE.
    • Preserve a configured service account and pod-template imagePullSecrets; never replace an admin-managed reference merely because supplied image config is enabled.
    • With both settings false, verify that Devsy does not read the client's Docker credentials or fetch the cluster's registry secret. Existing daemon-configuration Secrets and baseline Kubernetes permissions are separate and still required.
    • Errors identify the option, path and invalid field/category without echoing image environment, label contents or full metadata. Distinguish “file rejected” from cluster ImagePullBackOff; never suggest client docker login as the remedy for a missing cluster pull authorization in this mode.

    5. Tests and observable acceptance

    Deterministic unit/contract coverage

    Extend the contributor's pkg/driver/kubernetes/image_details_test.go and pkg/devcontainer/image_details_test.go:

    • Unset option preserves inspection. A configured valid file uses no registry inspector; a configured parser/read/scope error also uses no inspector.
    • Cover missing/null/empty config, valid all-empty config, wrong types, extra/trailing JSON, unsupported schema, invalid UTF-8, exactly-at/above size cap and nonregular files.
    • Cover exact repository/digest match, wrong repository, wrong digest, tag-only image, arbitrary Docker Id, platform mismatch, missing ARCHITECTURE, and multi-platform fixtures.
    • Verify all five fields, env values containing =, literal entrypoint/command argv, remote/container user precedence, valid inherited lifecycle metadata and malformed metadata failure.
    • Guard every excluded configuration before Feature/build/registry calls, including CLI-added Features and recovery. Assert fresh-create and explicit-recreate failures cause no pod/PVC mutation.
    • Existing-workspace up validates the input but preserves the saved pod/runtime metadata until recreation. Moving an otherwise identical local file does not replace a healthy pod.
    • Assert local path removal from persisted pod options, without changing the in-memory provider option; status/stop/delete remain usable with the file removed.
    • Preserve cluster service-account/pull-secret references. With SSH_INJECT_DOCKER_CREDENTIALS=false and KUBERNETES_PULL_SECRETS_ENABLED=false, client credential-helper and cluster registry-secret read spies must not be called.

    GitHub Actions integration

    Extend the contributor's e2e/tests/up/provider_kubernetes_image_config_file.go and register its label in hack/ci/suites.yaml. Use the existing Kubernetes harness and owned CI fixtures.

    1. Actual private registry separation. CI publishes a dedicated fixture image and its sidecar using a setup identity. Provision the cluster's service account/pull secret separately. Run Devsy with an isolated empty Docker credential directory, no cloud-registry credentials/helper access, explicit ARCHITECTURE, context SSH_INJECT_DOCKER_CREDENTIALS=false and provider KUBERNETES_PULL_SECRETS_ENABLED=false. The test identity must lack permission to read the admin's image-pull secret while retaining Devsy's normal namespace/daemon-secret permissions.
    2. Negative control. Without the file, the same client cannot inspect that private image. Confirm the expected registry authorization error.
    3. Positive flow. With the file, up succeeds, the pod runs the expected digest, and the registry records no anonymous/client inspection attempts during the launch interval. The node's authenticated image pull must actually occur; a public image or a cache-only success is insufficient.
    4. Behavior parity. Verify effective user, image env, explicit overrides, metadata lifecycle markers and entrypoint/cmd behavior against an authenticated control launch of the same image. Use separate fixtures where overrideCommand: false and timeout-disabled policy are needed to observe an image entrypoint.
    5. Restart and data. Stop and start normally, then explicitly recreate with valid input. Preserve workspace/PVC identity and a sentinel. A changed invalid file during recreation must preserve the old running pod.
    6. Failure modes. Exercise missing/mismatched file and wrong architecture before pod creation; exercise missing cluster pull authorization separately and require an actionable cluster pull error.
    7. No new cluster-wide permissions. Run the successful flow with node-list denied and explicit architecture, and keep registry-secret reads denied. Do not remove permissions needed by unrelated existing Devsy operations and call that a feature failure.

    Run focused Go tests and lint, then the registered CI scenario against the actual candidate CLI and delivered agent. Source-level fake-inspector tests and a file-injected environment marker alone do not complete customer acceptance.

    6. Documentation and delivery

    • Add a user guide at sites/docs-devsy-sh/content/docs/managing-providers/kubernetes-registry-access.mdx, register it in that directory's meta.json, and link it from manage-providers.mdx.
    • Document the versioned file, CI export example, digest/platform pairing, ARCHITECTURE versus scheduling, per-workspace --provider-option, stable absolute paths for Desktop, existing cluster pull configuration, baseline RBAC, and explicit recreation for changed image metadata.
    • Update the driver capability documentation added by the contributor under developing-providers/driver.mdx to match the final request/result contract and strict fallback rules.
    • Open a signed-commit Draft PR from the contributor work or a coordinated continuation. Reference this issue and preserve attribution. Review slices may separate provider/parser wiring, runner integration and end-to-end/docs, but the issue stays open until all supported customer-flow criteria pass.

    Completion: a namespace-scoped client without image-registry credentials starts a digest-pinned prebuilt workspace using cluster pull authorization, obtains the same user/environment/metadata/entrypoint behavior as authenticated inspection, and gets deterministic errors for invalid or unsupported file mode. No helper pod or additional registry-secret access is introduced.

  4. added a commit that references this issue on Oct 31, 2026
    0074d32
  5. wsmoak commented on Oct 31, 2026

    @wsmoak
    ContributorAuthor

    I've rebased the branch onto current main (3242016) and fixed these:

    • Local path kept out of pod options (wsmoak@ca7f9bc). IMAGE_CONFIG_FILE is no longer stored in the last-applied pod annotation, and it no longer counts in optionsEqual. Moving or renaming the file won't replace the pod, and the client path isn't written to the cluster.
    • Empty config accepted (wsmoak@daedcc4). The check is now whether the config object exists, not whether any of its fields are set. config: {} is valid. A missing, null or non-object config is rejected.
    • ARCHITECTURE required (wsmoak@ef33531). Setting IMAGE_CONFIG_FILE without ARCHITECTURE is an error, so Devsy never lists nodes in this mode. A file whose architecture doesn't match is also rejected. The docs now say that a mixed-architecture cluster still needs NODE_SELECTOR for scheduling.
    • Invalid metadata rejected (wsmoak@5aab832). In this mode, a malformed devcontainer.metadata label (bad JSON, null, null entries, wrong types) is an error instead of a warning that gets ignored. Registry inspection behaves as before.

    WIP remains on branch main...wsmoak:devsy:feat/k8s-image-details

    I still need to test the latest changes with a full setup (the original set worked fine) so this isn't ready to review yet.

    The commits are now signed. This is 100% Claude Code + Opus 5.5 generated.

  6. wsmoak commented on Oct 31, 2026

    @wsmoak
    ContributorAuthor

    I've tested with these commits cherry picked on top of v1.24.0 with my AWS EKS setup and it all works fine for me.

    Shall I open a pull request? I am hesitant because I cannot actually explain every line of this as required in the pull request template. If you'd rather consider it a proof of concept and re-implement from requirements that is fine. I can still sign a CLA if needed.

    From the very large comment above, are any of these blocking?

    1. Versioned wrapper with a digest match. Right now crane config > file works with no further steps. A wrapper would add a conversion step and rule out tagged images. The file is operator-supplied and trusted, and as you note, a digest match doesn't prove the bytes came from that image. Would a docs recommendation to pin by digest be enough for a first version?
    2. Rejecting unsupported combinations (Features, Dockerfile, Compose, recovery, prebuild, workspace build). Today the file only replaces inspection of the devcontainer.json image. Dockerfile base images are still inspected as before. Should the first version fail on all of these up front, or is it enough to document that it applies to plain image: only?
    3. File reading limits (size cap, regular files only, UTF-8). These are easy to add if you want them, though the path comes from the operator.
    4. Private-registry e2e with separate identities and registry access logs. The current e2e shows the file is used, and unit tests cover the no-fallback behavior. The full credential-separation setup is a big CI fixture. Could that be a follow-up?
    5. Docs. The driver.mdx section is updated. Do you want a separate page under managing-providers as well?
  7. skevetter commented on Oct 31, 2026

    @skevetter
    Contributor

    @wsmoak you are welcome to open a PR. If anything is missing, I will add on to your PR.

    From the very large comment above

    I am trying something new where I put the plans in the Issue comments section for an agent to pick up the work. The thought being consistent implementation for those looking to use their agents to perform work. Or at least some level of sanity check.

    I am a bit overloaded at the moment between personal life obligations, professional work, and this side project. That is to say, I will try my best to get to it when I have available bandwidth but the approaching holidays is also cutting into my availability.

    I would love having more time to work on issues/feature request directly but that is not an available opportunity at the moment.

  8. skevetter commented on Oct 31, 2026

    @skevetter
    Contributor

    Continued the contributor branch in #1739, preserving contributor authorship. The implementation adds the versioned digest-bound file format, launch-scope validation, per-launch snapshots, and local-path redaction from pod options and container setup payloads. The live private-registry acceptance flow and local validation pass. GitHub CI and hosted reviews are in progress. The contributor CLA signature is still required. No merge has been performed.

  9. skevetter commented on Nov 1, 2026

    @skevetter
    Contributor

    The continuation is ready for human merge in #1739 at cf94f45. All required GitHub checks pass, including the 94-job implementation workflow, contributor agreement, and commit signatures. Greptile reviewed the final head at 5/5. Local and hosted CodeRabbit reviews have no actionable findings remaining. The private-registry startup and lifecycle scenario passes locally and in the Kubernetes CI suite. Live AWS/EKS and native Windows Kubernetes launch were not run. No merge has been performed.

  10. skevetter commented on Nov 11, 2026

    @skevetter
    Contributor

    completed

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    enhancementNew feature or request

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions