> For the complete documentation index, see [llms.txt](https://docs.bluerock.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.bluerock.io/bluerock-documentation-2.7.0-beta/release-notes/bluerock-2.7.0-26.38.0.md).

# BlueRock 2.7.0  (26.38.0)

### Purpose of this Document

This document provides information about the features, enhancements, and known issues in BlueRock Release 2.7.0 (26.38.0). It applies to both new deployments and upgrades from earlier versions.

This release introduces robust Policy Enhancements, including human-in-the-loop approval and the BlueWarden egress security proxy; expanded BlueRock Connector capabilities, such as remote file share mounting; and secure Okta SSO integration via the BlueDev Identity Deployment Kit.

***

### Revision History

| **Release Version** | **Release Date** |
| ------------------- | ---------------- |
| v2.7.0 (26.38.0)    |                  |

***

## Supported Platforms / Distributions

BlueRock Release v2.7.0 (26.38.0) supports deployment across major public cloud providers.

The following operating systems have been validated for this release.

### AWS

| **Distribution**  | **Kernel** |
| ----------------- | ---------- |
| Amazon Linux 2023 | 6.12.114   |
| Ubuntu 24.04      | 6.12.114   |

### GCP

| **Distribution** | **Kernel** |
| ---------------- | ---------- |
| Ubuntu 24.04     | 6.12.114   |

### Azure

| **Distribution** | **Kernel** |
| ---------------- | ---------- |
| Ubuntu 24.04     | 6.12.114   |

***

## New Features and Enhancements

This release introduces robust Policy Enhancements including human-in-the-loop approval and the BlueWarden egress security proxy, expanded BlueRock Connector capabilities such as remote file share mounting, and secure Okta SSO integration via the BlueRock Identity Kit.

### Policy Enhancements

#### Human in the Loop Approval

BlueRock provides policy rules that gate coding agents (Claude Code, Antigravity, Cursor, and Codex). These rules require human approval before executing specific tools or commands, rather than relying solely on logging or blocking remediations.

When a command or tool execution matches a configured policy, BlueRock presents the agent's native permission prompt to the operator, holding execution until explicit approval is granted. Interactive approval prompts display exclusively for Claude Code. For agents that do not support interactive approval prompts (such as Antigravity, Cursor, or Codex), configure `remediate: true` to enforce a hard block.

```json
{
  "version": "26.38_bru-release-26-38-0",
  "app_policies": {
    "default": {
      "claude_sensor": {
        "tool_guard": {
          "enable": true,
          "remediate": "approval",
          "denied": [ "WebFetch" ]
        },
        "command_guard": {
          "enable": true,
          "remediate": "approval",
          "patterns": [ "git push -f", "git push --force" ]
        }
      }
    }
  }
}
```

\
**Limitations**

* **Claude Code**: \
  Fully supports interactive approval prompts (`remediate: "approval"`), including when permissions are bypassed.
* **Antigravity, Cursor, Codex**:\
  Does not support interactive approval prompts. Configuring `remediate: "approval"` logs the action and permits execution. Set `remediate: true` to block execution.
* **Out-of-Path / Non-Sandbox Execution**: \
  Human-in-the-Loop policy enforcement operates strictly for coding agents running inside the BlueRock Sandbox container. Policy enforcement cannot occur for coding agents running outside the sandbox environment or inspection path.

#### Per User Policy

Administrators can configure runtime Sandbox policies and apply the policies directly to the BlueRock Sandbox created and accessed by specific user principals. The system authenticates these user principals via Google, Entra, Okta Single Sign-On (SSO), or SSH key authentication.

#### Sandbox Policies

In this release, BlueRock introduces granular observability configurations and system call controls:

* **File Operation Observability:** \
  Emit observability events for all file operations, or restrict events strictly to file write operations (`only_writes`) to prevent event flooding.
* **File Deletion Tracking:** \
  Observe specific file deletion operations inside the sandbox container.
* **Path Execution Restrictions:** \
  Restrict coding agent execution strictly to explicit file paths.
* **`io_uring` Interface Limits:** \
  Restrict `io_uring` system call usage inside the sandbox container.

**System Call Evaluation & Fail-Closed Posture**

* **Standard Evaluation:** \
  Monitored system calls evaluate against active policy rules and enforce the configured remediation (`allow`, `block`, or `approval`).
* **Evaluation Fault Behavior (Fail-Closed):** \
  If BRace cannot complete a policy evaluation due to a system fault (for example, if the connection between BRace and `bluerockd` drops and cannot be restored), BRace automatically denies the system call. The application receives a `permission denied` error, ensuring the sandbox container remains protected during evaluation failures.

#### BlueWarden (Egress Security)

BlueWarden operates as an optional, per-container egress HTTPS proxy for coding agents running inside the BlueRock Sandbox container.

**Enablement and Configuration:**&#x20;

Administrators enable and configure BlueWarden by defining the `warden` block within the Sandbox application policy. A minimal structural example is provided below:

```json
{
  "warden": {
    "options": {
      "remediate": false,
      "fail_closed": false
    },
    "egress": {
      "block_quic": true,
      "destinations": {
        "allow_to": [],
        "deny_to": []
      }
    }
    // Additional configurations for tls, http, dns, llm, and mcp are defined here.
  }
}
```

Supported egress policies include:

* **HTTP/HTTPS Endpoint Filtering:** \
  Controls which upstream hosts and URL paths the agent's requests allow.
* **Model Pinning:** \
  Governs which LLM IDs the agent may call.
* **DNS Control:** \
  Inspects DNS lookups and responses, governing DNS-over-HTTPS and DNS-over-TLS.
* **LLM Response Observation:** \
  Decodes the model's reply stream to emit telemetry regarding responses and tool-call intent.
* **L4 Egress Control:** \
  Denies all non-web TCP and UDP traffic by default unless explicitly allowed by destination IP and port. BlueWarden automatically drops QUIC connections to force clients to fall back to inspectable TCP.
* **Anti-SSRF Invariants:** \
  Re-resolves the request Host and inherently denies connections to private and cloud-metadata addresses. BlueRock strictly enforces the metadata address range and never relaxes the range.

#### Bouncer Policy

The Bouncer policy allows administrators to govern the specific bouncer operations users can perform on remote development workspaces such as creating, starting, stopping, renaming, mounting file shares, and destroying workspaces. The policy also enforces caps on the maximum number of remote sandbox containers a single user principal can create.

The policy requires two configurations:

* **`bouncer_contract`:** \
  A named contract defining policy options.
* **`bouncer_contract_mapping`:** \
  A mapping of the bouncer contract to a user principal ID.

  ```json
  {
    "bouncer_contracts": {
      "default": {
        "capabilities": { "destroy": { "enabled": false } },
        "limits": { "max_containers_per_principal": 3 }
      },
      "admin": {
        "limits": { "max_containers_per_principal": 0 }
      },
      "attach-only": {
        "capabilities": {
          "up": { "enabled": false },
          "start": { "enabled": false },
          "stop": { "enabled": false },
          "destroy": { "enabled": false },
          "rename": { "enabled": false }
        }
      },
      "catalog-only": {
        "capabilities": { "up": { "url_source": false, "shares": false } }
      }
    },
    "bouncer_contract_mapping": {
      "rules": [
        { "principal": "admin.mail@domain.com", "contract": "admin" },
        { "principal": "*@contractor.domain.com", "contract": "attach-only" },
        { "principal": "key:SHA256:*", "contract": "catalog-only" }
      ],
      "default": "default"
    }
  }
  ```

  <br>

  | **User**                                    | **Contract** | **Effect**                                                                                                               |
  | ------------------------------------------- | ------------ | ------------------------------------------------------------------------------------------------------------------------ |
  | <admin.mail@domain.com>                     | admin        | Every action is allowed, and there is no container limit.                                                                |
  | Anyone at contractor.domain.com             | attach-only  | Can attach to existing containers but cannot create, start, stop, destroy, or rename them. The limit is 5 (the default). |
  | Any user authenticated with a plain SSH key | catalog-only | The `up` command works only from catalog templates; no git URLs or remote shares are permitted.                          |
  | Everyone else                               | default      | Cannot destroy containers, and the limit is a maximum of 3 containers.                                                   |

***

### BlueRock Connector

#### Multi-Platform Support

The BlueRock Connector extends platform support to Linux, joining existing macOS and Windows support. Linux packages are provided as `.deb` and `.rpm` files for x86-64 and arm64 architectures across validated distributions: Debian, Ubuntu, RHEL, Fedora, and Amazon Linux.

#### Sandbox Idle Timeout Control

The BlueRock Connector extension/application introduces configurable options on the client side to maintain the running state of the remote sandbox container on the BlueRock Host/VM, or automatically stop the container after a disconnection.

The extension includes an Autostop configuration section with the following controls:

* Keep running (never autostop): Keeps the sandbox running on the BlueRock Host/VM after the client side disconnects. The user must stop the container manually.
* Grace after normal disconnection (minutes): Configures the waiting period after the client side editor closes.
* Grace after dropped connection (minutes): Configures the waiting period after a client side connection drops unexpectedly.

#### **Mount Remote File Share**

The BlueRock Connector extension/application supports mounting external file storage directly onto the BlueRock Sandbox container running on the BlueRock Host/VM. Supported external file storage includes:

* AWS EFS and AWS FSx
* Azure Files

#### CLI `--stdio` Proxy Command Support

The BlueRock Connector CLI introduces the `--stdio` option. This option routes a single SSH connection between stdin/stdout and the local bridge process, enabling Claude Code Desktop IDE to establish SSH connections to remote sandbox workspaces under `disableDesktopLocalSessions`.

#### Port Forwarding

The BlueRock Connector extension/application securely exposes server applications running inside the remote BlueRock Sandbox directly to the local client-side desktop environment by executing a `bluedev-relay` program inside the sandbox container.

***

### BlueDev Identity Deployment Kit

#### **Okta SSO Support**

The Identity Kit integrates with Okta OpenID Connect (OIDC) applications to permit secure remote workspace logins. This integration allows users to seamlessly authenticate and access the remote BlueRock Sandbox using their Okta account ID.

#### Auto-Renewal of Host Certificate

For the BlueDev container deployment using SSO, the BlueRock Host receives a host certificate with a fixed lifetime at the time of host enrollment with StepCA. BlueRock automatically renews these host certificates to prevent service disruption, eliminating the need for manual administrative intervention to maintain host connectivity.

***

## Fixed Issues

***

## Known Issues

### BA-3057: BlueWarden does not enforce `client.http_servers.deny_http` and `deny_sse`

BlueWarden does not enforce the `client.http_servers.deny_http` and `client.http_servers.deny_sse` policy settings. Sandboxed agents can connect to MCP servers over HTTP and HTTP+SSE, even when administrators enable both denial parameters with an empty exception list.

**Workaround**

Configure the `tools.deny_list` policy for each specific MCP server IP address or hostname to restrict tool execution.

***

### BA-3055: BlueWarden MCP client server lists require host IP matching

BlueWarden evaluates MCP server connection filters (`tools`, `prompts`, and `resources`) against destination host IP addresses rather than server-provided identity names (`serverInfo`). Configuring connection filters using server identity names (such as `"FileServer"`) prevents policy rules from matching network traffic.

**Workaround**

In the MCP client policy, configure policy lists (such as target server allowlists) using destination host/server IP addresses (e.g., `"10.0.0.13"`) or explicit IP regex patterns (e.g., `"^10\\.0\\.0\\.13$"`) instead of server names specified in the MCP server program.

***

### BA-3047: HTTP endpoint deny lists do not block provider-mediated web searches

HTTP endpoint deny-list policies enforce network filtering on direct web requests initiated inside the sandbox container (such as standard `curl` calls or Claude Code `WebFetch`). However, when coding agents utilize provider-hosted search tools (such as Codex using OpenAI search backend), the provider fetches web content externally on its backend. Because request traffic originates outside the local sandbox, BlueWarden cannot block provider-mediated search queries.

**Workaround**

Configure HTTP endpoint rules to block access to provider search backend endpoints (such as `chatgpt.com/backend-api/codex/alpha/search`) to prevent provider-mediated web searches.

***

### BC-3441: Large Claude Code command-line handshakes truncated by `bluerockd`

When **Claude Code** executes **Bash** commands through the `brace` shim, extensive file mounts can cause the initial connection message sent to `bluerockd` to exceed the 64 KiB limit. As a result, `bluerockd` drops the oversized message, causing Bash commands in Claude Code to fail with an I/O error (`unexpected end of file`).

**Workaround**

Perform the following steps in the developer's environment prior to initiating Claude Code or creating the sandbox session:

* Create a symlink pointing `~/.local/bin/bwrap` to the system bubblewrap binary:

  ```shellscript
  ln -sf /usr/bin/bwrap ~/.local/bin/bwrap
  ```
* Verify that `~/.local/bin` precedes the `brace` shim directory in the `PATH` environment variable:

  ```shellscript
  echo $PATH
  ```
* Launch Claude Code, now Claude Code uses `/usr/bin/bwrap` directly from `PATH`, bypassing the `brace` shim during command execution.

***

### BC-3432: Unexpected `brace_connect` events when Warden is disabled on the host

When any BlueWarden policy rules (`warden.http`, `warden.llm`, or `warden.mcp`) remain enabled in the policy configuration, `brace_connect` events continue to be generated even if `brace.syscalls.connect` is configured to `minimal`.

**Workaround**

To suppress these unmatched events, explicitly set unused `warden.http`, `warden.llm`, and `warden.mcp` rules to disabled within the policy configuration.

***

### BC-3371 Restarting bluerockd disrupts existing sensor connections

Restarting the BlueRock Control Plane service disconnects existing BlueRock sensor connections, interrupting client-side AI agent and MCP applications.

**Workaround**

Restart all affected AI agent and MCP applications after restarting the `bluerockd` service.

***

### BC-3381 Source-address ingress firewall rules not enforced

Source-address-based ingress firewall rules are not correctly enforced for BlueRock Sandbox containers.

**Workaround**

No workaround is currently available.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.bluerock.io/bluerock-documentation-2.7.0-beta/release-notes/bluerock-2.7.0-26.38.0.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
