forge_wal_anchor_interval_ms: 3_600_000,

  forge_wal_dir: nil,

  forge_wal_bucket: nil,

  # The bucket behind `/releases/<name>`. It grants every object to `allUsers`,

  # so the proxy needs no credential — the name is deployment policy, not a

  # secret, and it has a default so a development server serves the same

  # artifacts production does.

  releases_bucket: "openagentsgemini-cli-releases",

  # The seam `test/openagents_web/controllers/release_controller_test.exs`

  # stubs. Empty everywhere else, so the request options the controller builds

  # are the ones that reach the bucket.

  releases_request_options: [],

  forge_gcs_token_provider: nil,

  forge_rolling_provider: nil,

  # Hot-load allowlist: MODULE names, not repo paths. An entry ending in `.`

    forge_wal_adapter: forge_wal_adapter,

    forge_wal_dir: required_text.("OPENAGENTS_FORGE_WAL_DIR"),

    forge_wal_bucket: optional_text.("OPENAGENTS_FORGE_WAL_BUCKET"),

    releases_bucket:

      optional_text.("OPENAGENTS_RELEASES_BUCKET") ||

        Application.fetch_env!(:openagents, :releases_bucket),

    ra_enabled: ra_enabled,

    ra_data_dir: required_text.("OPENAGENTS_RA_DATA_DIR"),

    ra_expected_size: parse_integer.("OPENAGENTS_RA_EXPECTED_SIZE", 1..100),

  @timestamps_opts [type: :utc_datetime_usec]

  @reserved_slugs ~w(

    admin api assets auth changelog chat components computers controller data dev device docs git og

    health healthz leaderboard machines memory repositories sarah settings status voice

    health healthz leaderboard machines memory releases repositories sarah settings status voice

  )

  def reserved_slugs, do: @reserved_slugs

defmodule OpenAgentsWeb.ReleaseController do

  @moduledoc """

  Serves CLI release artifacts out of the public release bucket.

  The binaries are not in the repository and never will be: a 40 MB executable

  per platform per version turns a clone into a download. They live in a

  world-readable Cloud Storage bucket, and this route is the one durable name

  in front of them, so `https://openagents.com/releases/<name>` keeps working

  when the bucket behind it is renamed or replaced.

  The proxy therefore adds no authority. Every object it serves is already

  readable by anyone who knows the bucket URL, so there is nothing here to

  authenticate and nothing to withhold. It adds a stable URL, the content type

  and cache lifetime the object deserves, and a strict allowlist on the object

  name so that the one path segment a caller controls cannot address anything

  outside the bucket.

  `priv/static/install.sh` is the client this contract exists for, and it is

  the reason `Range` is honoured rather than ignored. For an artifact of 16 MiB

  or more the installer reads `Content-Length` with a `HEAD`, then fetches

  eight ranges concurrently and concatenates them. A ranged request answered

  with `200` and the whole body would produce eight complete copies

  concatenated into one corrupt binary that still passes as a download, so the

  `206` is a correctness requirement rather than an optimization.

  """

  use OpenAgentsWeb, :controller

  import Plug.Conn

  require Logger

  @storage_host "https://storage.googleapis.com"

  # One segment, and a conservative one. Letters, digits, dot, underscore, and

  # hyphen cover every object we publish (`openagents-0.1.0-rc.1-macos-aarch64`,

  # `SHA256SUMS-0.1.0-rc.1`, `stable`) and admit no slash, no percent escape,

  # and no leading dot. The caller controls this segment and it is interpolated

  # into an outbound URL, so the allowlist is the boundary that keeps the

  # request inside the bucket.

  @name_pattern ~r/\A[A-Za-z0-9][A-Za-z0-9._-]*\z/

  @name_max_bytes 128

  # A ranged request is passed through verbatim, so its shape is checked here

  # rather than trusted. Only the byte-range syntax the installer sends is

  # forwarded; anything else is dropped and the whole object is served.

  @range_pattern ~r/\Abytes=[0-9,\- ]+\z/

  # A version-pinned artifact and its sums file are the same bytes forever, so

  # a client that has one never needs to ask again. A channel pointer is the

  # opposite: `stable` is a name that moves, and caching it for a year would

  # pin every installer that read it to the release it named that day. Getting

  # these two the wrong way round is how a fleet ends up stuck on an old

  # version with no way to tell it otherwise.

  @immutable_cache "public, max-age=31536000, immutable"

  @pointer_cache "public, max-age=60"

  @streamable_statuses [200, 206]

  def show(conn, %{"name" => name}) when is_binary(name) do

    if admitted_name?(name) do

      proxy(conn, name)

    else

      not_found(conn)

    end

  end

  # Anything that does not arrive as one string names no object. The bucket is

  # flat, and a deeper path never reaches here: `releases` is a reserved slug,

  # so the router answers `/releases/a/b` with the site's own 404 page.

  def show(conn, _params), do: not_found(conn)

  defp admitted_name?(name) do

    byte_size(name) <= @name_max_bytes and

      Regex.match?(@name_pattern, name) and

      not String.contains?(name, "..")

  end

  defp proxy(conn, name) do

    url = object_url(name)

    headers = upstream_headers(conn)

    if head_request?(conn) do

      case Req.head(url, request_options(headers)) do

        {:ok, response} -> answer_head(conn, name, response)

        {:error, reason} -> unavailable(conn, name, reason)

      end

    else

      case Req.get(url, request_options(headers) ++ [into: :self]) do

        {:ok, response} -> answer_get(conn, name, response)

        {:error, reason} -> unavailable(conn, name, reason)

      end

    end

  end

  defp answer_head(conn, name, %Req.Response{status: status} = response)

       when status in @streamable_statuses do

    conn

    |> put_artifact_headers(name, response)

    |> send_resp(status, "")

  end

  defp answer_head(conn, name, response), do: refuse(conn, name, response)

  defp answer_get(conn, name, %Req.Response{status: status, body: body} = response)

       when status in @streamable_statuses do

    conn =

      conn

      |> put_artifact_headers(name, response)

      |> send_chunked(status)

    # `body` is a `Req.Response.Async`, so the artifact crosses this process one

    # chunk at a time and a 40 MB binary is never a 40 MB message. A client that

    # walks away mid-download closes the socket; halting cancels the upstream

    # read rather than draining the rest of the object into a closed connection.

    Enum.reduce_while(body, conn, fn data, current_conn ->

      case chunk(current_conn, data) do

        {:ok, next_conn} -> {:cont, next_conn}

        {:error, :closed} -> {:halt, current_conn}

      end

    end)

  end

  defp answer_get(conn, name, %Req.Response{body: %Req.Response.Async{}} = response) do

    Req.cancel_async_response(response)

    refuse(conn, name, response)

  end

  defp answer_get(conn, name, response), do: refuse(conn, name, response)

  defp refuse(conn, _name, %Req.Response{status: 404}), do: not_found(conn)

  # The bucket rejected the range the client asked for. Say so, rather than

  # reporting it as a fault of ours: the client chose the range and is the only

  # party that can choose a different one.

  defp refuse(conn, _name, %Req.Response{status: 416}) do

    conn

    |> put_resp_header("accept-ranges", "bytes")

    |> put_resp_header("x-content-type-options", "nosniff")

    |> send_resp(416, "")

  end

  defp refuse(conn, name, %Req.Response{status: status}) do

    Logger.warning("release object #{name} answered #{status} from the bucket")

    conn

    |> put_resp_content_type("text/plain", "utf-8")

    |> put_resp_header("x-content-type-options", "nosniff")

    |> send_resp(502, "The release store did not answer.\n")

  end

  defp unavailable(conn, name, reason) do

    Logger.warning("release object #{name} could not be read: #{failure_kind(reason)}")

    conn

    |> put_resp_content_type("text/plain", "utf-8")

    |> put_resp_header("x-content-type-options", "nosniff")

    |> send_resp(502, "The release store did not answer.\n")

  end

  # The kind of failure, never the payload that carried it. A log line records

  # that the bucket was unreachable and how; the exception itself may quote a

  # URL or a header, and `test/openagents/log_safety_test.exs` refuses the shape

  # that would put one in a log.

  defp failure_kind(%Req.TransportError{reason: reason}), do: "transport #{reason}"

  defp failure_kind(%{__struct__: module}), do: inspect(module)

  defp failure_kind(_other), do: "unknown"

  defp not_found(conn) do

    conn

    |> put_resp_content_type("text/plain", "utf-8")

    |> put_resp_header("x-content-type-options", "nosniff")

    |> send_resp(404, "Not found.\n")

  end

  defp put_artifact_headers(conn, name, response) do

    {type, charset} = content_type(name)

    conn

    |> put_resp_content_type(type, charset)

    |> put_resp_header("cache-control", cache_control(name))

    |> put_resp_header("x-content-type-options", "nosniff")

    |> put_resp_header("accept-ranges", "bytes")

    |> copy_upstream_header(response, "content-length")

    |> copy_upstream_header(response, "content-range")

  end

  # `content-length` is set before the response is sent, which is what makes

  # `HEAD` answer with the artifact's real size. Bandit streams a

  # length-delimited body rather than a chunked one once the length is

  # declared, and suppresses the body entirely for a `HEAD`, so the same code

  # path serves both the installer's size probe and its download.

  defp copy_upstream_header(conn, response, name) do

    case Req.Response.get_header(response, name) do

      [value | _rest] -> put_resp_header(conn, name, value)

      [] -> conn

    end

  end

  # `Plug.Head` rewrites `HEAD` to `GET` before the router sees the request, so

  # `conn.method` cannot answer this. The adapter still holds the method the

  # client actually sent. An adapter that stops carrying it falls through to

  # `false`, which costs a discarded body rather than a wrong answer.

  defp head_request?(%Plug.Conn{adapter: {_adapter, %{method: "HEAD"}}}), do: true

  defp head_request?(%Plug.Conn{}), do: false

  defp content_type("openagents-" <> _rest), do: {"application/octet-stream", nil}

  defp content_type(_name), do: {"text/plain", "utf-8"}

  defp cache_control("openagents-" <> _rest), do: @immutable_cache

  defp cache_control("SHA256SUMS-" <> _rest), do: @immutable_cache

  defp cache_control(_name), do: @pointer_cache

  defp upstream_headers(conn) do

    # Ask the bucket for the stored bytes. Req negotiates compression by

    # default, and a compressed transfer would make the `content-length` this

    # route forwards describe the encoded body rather than the artifact the

    # client is about to checksum.

    identity = [{"accept-encoding", "identity"}]

    case get_req_header(conn, "range") do

      [range | _rest] ->

        if Regex.match?(@range_pattern, range), do: [{"range", range} | identity], else: identity

      [] ->

        identity

    end

  end

  defp request_options(headers) do

    Keyword.merge(

      [

        headers: headers,

        decode_body: false,

        # The installer already retries by falling back to a serial download,

        # and a retry of a partially streamed body would restart it from the

        # top into a response that is already open.

        retry: false,

        receive_timeout: 60_000

      ],

      Application.get_env(:openagents, :releases_request_options, [])

    )

  end

  defp object_url(name) do

    bucket = Application.fetch_env!(:openagents, :releases_bucket)

    "#{@storage_host}/#{bucket}/#{name}"

  end

end

          --%>

        </Landing.hero>

        <%!-- The shortest path from reading about it to holding it. Deliberately

        quiet: one line under the hero rather than a third call to action

        competing with the two above it. --%>

        <Landing.section id="home-install">

          <div class="flex flex-col items-center gap-3 text-center">

            <p class="text-sm text-muted-foreground">Install the CLI</p>

            <code

              id="home-install-command"

              class="w-full max-w-xl overflow-x-auto rounded-md border border-border bg-card px-4 py-3 text-left font-mono text-sm whitespace-nowrap text-foreground"

            >

              curl -fsSL https://openagents.com/install.sh | bash

            </code>

            <.link navigate={~p"/docs/install-cli"} class="text-sm text-muted-foreground underline">

              Other ways to install

            </.link>

          </div>

        </Landing.section>

        <Landing.feature_grid title="Everything the work needs. Nothing it doesn't.">

          <:item title="Issues" icon="file-document">

            Plan, assign, label and close, over an API shaped after the one you already

  # they are interpolated rather than written into the template, where the HEEx

  # parser would read them as tags.

  @cli_steps [

    %{command: "npx --yes @openagentsinc/cli@latest --version", note: "try without installing"},

    %{command: "npm i -g @openagentsinc/cli", note: "install"},

    %{command: "curl -fsSL https://openagents.com/install.sh | bash", note: "install"},

    %{command: "npm i -g @openagentsinc/cli", note: "or install with npm"},

    %{command: "openagents auth login", note: "sign in"},

    %{command: "openagents repo create <name>", note: "create"},

    %{command: "openagents repo clone <owner>/<repo>", note: "clone"},

    "/",

    "/status",

    "/changelog",

    "/coder",

    "/leaderboard",

    "/components",

    "/components/icons",

  defp policy(%{plug: OpenAgentsWeb.NotFoundController, verb: verb}) when verb in [:get, :head],

    do: declaration(:public_read, "anonymous", "published:not-found", false)

  # CLI release downloads. Public by construction: the route proxies a bucket

  # that already grants every object to `allUsers`, so it withholds nothing a

  # direct storage URL would hand over, and it only ever reads. It exists to

  # give the artifacts one durable name, not to gate them.

  defp policy(%{path: "/releases" <> _rest, verb: verb}) when verb in [:get, :head],

    do: declaration(:public_read, "anonymous", "published:cli-release", false)

  defp policy(%{path: path, verb: verb}) do

    cond do

      String.starts_with?(path, "/og/") and verb in [:get, :head] ->

    get "/v/:version/forum/t/:id", OgImageController, :forum_topic

  end

  # CLI release downloads. No pipeline: `:browser` accepts only HTML and would

  # refuse an installer asking for `application/octet-stream`, while `:api`

  # accepts only JSON and would refuse a browser. The route is public by

  # construction — it proxies a world-readable bucket — so there is no session

  # or bearer for a pipeline to establish.

  #

  # One segment, not `/*path`. The bucket is flat, so a deeper path names no

  # object; and `releases` is a reserved slug, which already gives every deeper

  # path a `NotFoundController` route below. A glob here would shadow that

  # route entirely and the compiler would say so.

  scope "/releases", OpenAgentsWeb do

    get "/:name", ReleaseController, :show

  end

  # Keep repository-shaped routes last. Every fixed product, API, operator,

  # Git, and development route above wins before a GitHub-backed namespace can

  # be interpreted from the first path segment.

export OPENAGENTS_INFERENCE_PROXY_URL="https://openagents.com/api/inference/proxy"

export OPENAGENTS_MACHINE_TOKEN_TTL_SECONDS="2592000"

export OPENAGENTS_MIGRATE_ON_BOOT="true"

export OPENAGENTS_RELEASES_BUCKET="openagentsgemini-cli-releases"

export OPENAGENTS_PRODUCTION_DEPLOY_ENABLED="true"

export OPENAGENTS_RA_DATA_DIR="/var/lib/openagents/ra"

export OPENAGENTS_RA_EXPECTED_SIZE="3"

  OPENAGENTS_INFERENCE_PROXY_URL OPENAGENTS_MACHINE_TOKEN_TTL_SECONDS

  OPENAGENTS_MIGRATE_ON_BOOT OPENAGENTS_PRODUCTION_DEPLOY_ENABLED

  OPENAGENTS_RA_DATA_DIR OPENAGENTS_RA_EXPECTED_SIZE

  OPENAGENTS_RELEASES_BUCKET

  OPENAGENTS_SECURE_COOKIES OPENAGENTS_STAGING_CLEANUP_ENABLED

  OPENAGENTS_STAGING_GATE PHX_HOST PHX_SERVER POOL_SIZE PORT GIT_SSH_COMMAND

)

# Install the OpenAgents CLI

The npm package is `@openagentsinc/cli`. It provides the `openagents` command

and requires Node.js 20 or later.

The CLI is a single native binary. Install it with the installer script:

## Install globally with npm

```sh

curl -fsSL https://openagents.com/install.sh | bash

```

The installer detects your operating system and processor, downloads the

matching build, verifies its SHA-256 checksum, and links `openagents` and `oa`

into `~/.openagents/bin`. It also adds that directory to `PATH` in your shell

configuration file. Open a new shell, then confirm the installation:

```sh

openagents --help

```

Run the same command again to update. The CLI does not include an

`openagents update` command.

## Install a specific version

Pass a version to the script when a script or qualification run must be

reproducible:

```sh

curl -fsSL https://openagents.com/install.sh | bash -s 0.1.0-rc.1

```

The version must read as `X.Y.Z` or `X.Y.Z-suffix`. The installer refuses

anything else before it downloads.

## Choose a channel

Without a version, the installer resolves a channel to the version that channel

currently names. `stable` is the default. Set `OPENAGENTS_CHANNEL` to follow a

different one:

```sh

curl -fsSL https://openagents.com/install.sh | OPENAGENTS_CHANNEL=beta bash

```

A channel is a pointer that moves, so the version you get today is not the

version you get next month. Pass an explicit version when you need the answer

to stay the same.

## Choose where the binary lands

Install the CLI globally when you use it regularly:

The installer links `openagents` and `oa` into `~/.openagents/bin`. Set

`OPENAGENTS_BIN_DIR` to link them somewhere already on your `PATH`:

```sh

curl -fsSL https://openagents.com/install.sh | OPENAGENTS_BIN_DIR="$HOME/.local/bin" bash

```

The downloaded binary itself always lands in `~/.openagents/downloads`.

## Supported platforms

| Platform | Build |

| --- | --- |

| macOS on Apple silicon | `macos-aarch64` |

| macOS on Intel | `macos-x86_64` |

| Linux on x86-64 | `linux-x86_64` |

| Linux on ARM64 | `linux-aarch64` |

| Windows on x86-64 | `windows-x86_64` |

On Apple silicon, a shell running under Rosetta reports an Intel processor. The

installer detects that and installs the native `macos-aarch64` build anyway.

On Windows, run the installer under Git for Windows or MSYS2 Bash. It installs

`openagents.exe` and `oa.exe`. Under WSL, use the Linux build: WSL is Linux, and

`uname -s` reports it as such.

## What the installer verifies

The installer downloads `SHA256SUMS-<version>` separately from the artifact and

compares the artifact against the entry that names it. It refuses to install

when the sums file is missing, when it names no entry for your platform, when

the checksums disagree, or when neither `shasum` nor `sha256sum` is available.

The bytes are never made executable before the comparison succeeds.

macOS builds are signed with an Apple Developer ID certificate and notarized by

Apple, so Gatekeeper admits them without a right-click override.

The installer has no local fallback. It installs what it downloaded or it fails

and says so.

## Verify a download by hand

Download the artifact and its sums file, then compare them yourself:

```sh

curl -fsSLO https://openagents.com/releases/openagents-0.1.0-rc.1-macos-aarch64

curl -fsSLO https://openagents.com/releases/SHA256SUMS-0.1.0-rc.1

shasum -a 256 openagents-0.1.0-rc.1-macos-aarch64

grep openagents-0.1.0-rc.1-macos-aarch64 SHA256SUMS-0.1.0-rc.1

```

The two hexadecimal digests must match exactly. On Linux, use `sha256sum` in

place of `shasum -a 256`.

## Install with npm instead

The npm package is `@openagentsinc/cli`. It provides the same `openagents`

command and requires Node.js 20 or later. Use it when you already manage your

tools with npm:

```sh

npm install --global @openagentsinc/cli

npm install --global @openagentsinc/cli@latest

```

The CLI does not include an `openagents update` command.

## Run one command with npx

Use `npx` when you want to run one CLI command without installing the package

## Configure Git authentication

After you install the CLI globally, configure only the current Git repository:

After you install the CLI, configure only the current Git repository:

```sh

openagents auth setup-git --local

    conn = get(conn, ~p"/")

    assert html_response(conn, 200) =~ "The Agent Forge"

  end

  test "the landing page names the one command that installs the CLI", %{conn: conn} do

    html = conn |> get(~p"/") |> html_response(200)

    assert html =~ ~s(id="home-install-command")

    assert html =~ "curl -fsSL https://openagents.com/install.sh | bash"

  end

end

defmodule OpenAgentsWeb.ReleaseControllerTest do

  @moduledoc """

  The contract `priv/static/install.sh` reads.

  The installer resolves a channel, downloads an artifact, and verifies it

  against a sums file, all through `/releases/<name>`. Two parts of that are

  load-bearing beyond the usual "did it return the bytes": a `HEAD` must state

  the artifact's real size, and a ranged request must answer `206` with only

  the range. The installer fetches eight ranges concurrently for anything of

  16 MiB or more and concatenates them, so a `200` with the whole body in reply

  to a range produces eight complete copies in one file — a corrupt binary that

  still looks like a successful download.

  The bucket is stubbed rather than reached. The tests are about what this

  route does with an upstream answer, and a test that needs the network is a

  test that reports someone else's outage as our regression.

  """

  use OpenAgentsWeb.ConnCase, async: false

  @bucket "releases-test-bucket"

  @artifact "openagents-0.1.0-rc.1-macos-aarch64"

  setup do

    original_bucket = Application.get_env(:openagents, :releases_bucket)

    original_options = Application.get_env(:openagents, :releases_request_options)

    Application.put_env(:openagents, :releases_bucket, @bucket)

    Application.put_env(:openagents, :releases_request_options, plug: {Req.Test, __MODULE__})

    on_exit(fn ->

      Application.put_env(:openagents, :releases_bucket, original_bucket)

      Application.put_env(:openagents, :releases_request_options, original_options)

    end)

    :ok

  end

  test "an artifact is served as opaque bytes a client may keep forever", %{conn: conn} do

    body = :binary.copy("o", 64)

    Req.Test.stub(__MODULE__, fn upstream ->

      assert upstream.method == "GET"

      assert upstream.host == "storage.googleapis.com"

      assert upstream.request_path == "/#{@bucket}/#{@artifact}"

      # Compression would make the length this route forwards describe the

      # encoded body rather than the bytes the installer checksums.

      assert Plug.Conn.get_req_header(upstream, "accept-encoding") == ["identity"]

      upstream

      |> Plug.Conn.put_resp_header("content-length", "64")

      |> Plug.Conn.send_resp(200, body)

    end)

    conn = get(conn, ~p"/releases/#{@artifact}")

    assert conn.status == 200

    assert conn.resp_body == body

    assert get_resp_header(conn, "content-type") == ["application/octet-stream"]

    assert get_resp_header(conn, "content-length") == ["64"]

    assert get_resp_header(conn, "accept-ranges") == ["bytes"]

    assert get_resp_header(conn, "x-content-type-options") == ["nosniff"]

    assert get_resp_header(conn, "cache-control") == ["public, max-age=31536000, immutable"]

  end

  test "a sums file is readable text a client may keep forever", %{conn: conn} do

    sums = "#{String.duplicate("a", 64)}  #{@artifact}\n"

    Req.Test.stub(__MODULE__, fn upstream ->

      assert upstream.request_path == "/#{@bucket}/SHA256SUMS-0.1.0-rc.1"

      upstream

      |> Plug.Conn.put_resp_header("content-length", to_string(byte_size(sums)))

      |> Plug.Conn.send_resp(200, sums)

    end)

    conn = get(conn, ~p"/releases/SHA256SUMS-0.1.0-rc.1")

    assert conn.status == 200

    assert conn.resp_body == sums

    assert get_resp_header(conn, "content-type") == ["text/plain; charset=utf-8"]

    assert get_resp_header(conn, "cache-control") == ["public, max-age=31536000, immutable"]

  end

  test "a channel pointer is text that expires quickly", %{conn: conn} do

    Req.Test.stub(__MODULE__, fn upstream ->

      assert upstream.request_path == "/#{@bucket}/stable"

      upstream

      |> Plug.Conn.put_resp_header("content-length", "11")

      |> Plug.Conn.send_resp(200, "0.1.0-rc.1\n")

    end)

    conn = get(conn, ~p"/releases/stable")

    assert conn.status == 200

    assert conn.resp_body == "0.1.0-rc.1\n"

    assert get_resp_header(conn, "content-type") == ["text/plain; charset=utf-8"]

    # `stable` is a name that moves. Caching it the way an artifact is cached

    # would pin every installer that read it to the release it named that day.

    assert get_resp_header(conn, "cache-control") == ["public, max-age=60"]

  end

  test "a ranged request is answered with only the range that was asked for", %{conn: conn} do

    Req.Test.stub(__MODULE__, fn upstream ->

      assert Plug.Conn.get_req_header(upstream, "range") == ["bytes=8-15"]

      upstream

      |> Plug.Conn.put_resp_header("content-range", "bytes 8-15/64")

      |> Plug.Conn.put_resp_header("content-length", "8")

      |> Plug.Conn.send_resp(206, "34567890")

    end)

    conn =

      conn

      |> put_req_header("range", "bytes=8-15")

      |> get(~p"/releases/#{@artifact}")

    assert conn.status == 206

    assert conn.resp_body == "34567890"

    assert get_resp_header(conn, "content-range") == ["bytes 8-15/64"]

    assert get_resp_header(conn, "content-length") == ["8"]

    assert get_resp_header(conn, "accept-ranges") == ["bytes"]

  end

  test "a HEAD states the artifact's real size without sending it", %{conn: conn} do

    Req.Test.stub(__MODULE__, fn upstream ->

      # The size probe never asks for the body. Answering the client's `HEAD`

      # with a `GET` upstream would pull 40 MB out of the bucket to throw away.

      assert upstream.method == "HEAD"

      upstream

      |> Plug.Conn.put_resp_header("content-length", "41943040")

      |> Plug.Conn.send_resp(200, "")

    end)

    conn = head(conn, ~p"/releases/#{@artifact}")

    assert conn.status == 200

    assert conn.resp_body == ""

    assert get_resp_header(conn, "content-length") == ["41943040"]

    assert get_resp_header(conn, "accept-ranges") == ["bytes"]

    assert get_resp_header(conn, "content-type") == ["application/octet-stream"]

  end

  test "an object the bucket does not hold is a plain 404", %{conn: conn} do

    Req.Test.stub(__MODULE__, fn upstream ->

      Plug.Conn.send_resp(upstream, 404, "<?xml version='1.0'?><Error>NoSuchKey</Error>")

    end)

    conn = get(conn, ~p"/releases/openagents-9.9.9-linux-x86_64")

    assert conn.status == 404

    refute conn.resp_body =~ "NoSuchKey"

  end

  test "a bucket that answers with a fault is not reported as ours", %{conn: conn} do

    Req.Test.stub(__MODULE__, fn upstream ->

      Plug.Conn.send_resp(upstream, 503, "unavailable")

    end)

    conn = get(conn, ~p"/releases/stable")

    assert conn.status == 502

  end

  test "a name outside the allowlist is refused before the bucket is asked" do

    Req.Test.stub(__MODULE__, fn _upstream ->

      flunk("a rejected name reached the bucket")

    end)

    # `..` and a leading dot are refused by shape, and an encoded slash arrives

    # as one segment holding a slash, which the allowlist does not admit.

    for name <- ["..", ".ssh", "a%2Fb", "openagents%200.1.0", "under..dot"] do

      conn = get(build_conn(), "/releases/" <> name)

      assert conn.status == 404, "#{name} was not refused"

    end

  end

  test "a deeper path names no object, and the reserved slug is what answers", %{conn: conn} do

    Req.Test.stub(__MODULE__, fn _upstream ->

      flunk("a multi-segment path reached the bucket")

    end)

    assert get(conn, "/releases/openagents/0.1.0").status == 404

  end

end

    assert has_element?(view, "#repository-cli")

    assert has_element?(view, "#repository-cli-copy-0")

    assert has_element?(view, ~s(a[href="/docs/openagents-cli"]))

    assert html =~ "npx --yes @openagentsinc/cli@latest --version"

    assert html =~ "curl -fsSL https://openagents.com/install.sh | bash"

    assert html =~ "npm i -g @openagentsinc/cli"

    assert html =~ "openagents auth login"

    assert html =~ "openagents auth setup-git --local"