const CoderCopy = {

  mounted() {

    this.applyShell()

    this.onClick = () => this.copy()

    this.el.addEventListener("click", this.onClick)

  },

  applyShell() {

    const windowsCommand = this.el.dataset.windowsCommand

    if (!windowsCommand) return

    const platform = navigator.userAgentData?.platform || navigator.platform || ""

    if (!/Win/i.test(platform)) return

    this.el.dataset.copyText = windowsCommand

    const hintEl = document.getElementById("copy-hint")

    if (hintEl) hintEl.textContent = " " + windowsCommand + " "

  },

  destroyed() {

    this.el.removeEventListener("click", this.onClick)

  },

# General application configuration

import Config

# `irm | iex` needs a text body. Without this, Plug.Static would serve

# `install.ps1` as application/octet-stream.

config :mime, :types, %{

  "text/plain" => ["ps1"]

}

config :phoenix,

  filter_parameters: [

    "authorization",

  def static_paths,

    do:

      ~w(assets fonts images favicon.ico favicon-32x32.png favicon-16x16.png apple-touch-icon.png robots.txt install.sh)

      ~w(assets fonts images favicon.ico favicon-32x32.png favicon-16x16.png apple-touch-icon.png robots.txt install.sh install.ps1)

  @doc """

  Prefixes for static files that are served under a digested name.

defmodule OpenAgentsWeb.CliInstall do

  @moduledoc """

  The published install command for each shell.

  Unix readers pipe `install.sh` into `sh`. Windows PowerShell has no `sh`,

  and its `curl` is `Invoke-WebRequest`, which does not accept `-fsSL`.

  Windows readers run `install.ps1` through `irm | iex`.

  """

  @unix "curl -fsSL https://openagents.com/install.sh | sh"

  @windows "irm https://openagents.com/install.ps1 | iex"

  def unix, do: @unix

  def windows, do: @windows

end

  """

  attr :id, :string, required: true

  attr :command, :string, required: true

  attr :windows_command, :string, default: nil

  attr :prompt, :string, default: "$", doc: "the shell prompt drawn before the command"

  attr :windows_prompt, :string, default: "PS>"

  attr :label, :string, default: "Copy the install command"

  attr :class, :any, default: nil

        class="install-command__button"

        data-copied="false"

        data-copy-text={@command}

        data-unix-command={@command}

        data-windows-command={@windows_command}

        data-unix-prompt={@prompt}

        data-windows-prompt={@windows_prompt}

        aria-label={@label}

        phx-hook=".CopyCommand"

      >

        <code class="install-command__text">

          <span class="install-command__prompt" aria-hidden="true">{@prompt}</span>{@command}

          <span class="install-command__prompt" aria-hidden="true">{@prompt}</span><span class="install-command__body">{@command}</span>

        </code>

        <span class="install-command__glyph" aria-hidden="true">

          <UI.icon name="copy" class="install-command__idle" />

    <script :type={Phoenix.LiveView.ColocatedHook} name=".CopyCommand">

      export default {

        mounted() {

          this.applyShell()

          this.el.addEventListener("click", async () => {

            try {

              await navigator.clipboard.writeText(this.el.dataset.copyText)

            }, 1600)

          })

        },

        applyShell() {

          const windowsCommand = this.el.dataset.windowsCommand

          if (!windowsCommand) return

          const platform = navigator.userAgentData?.platform || navigator.platform || ""

          if (!/Win/i.test(platform)) return

          const command = windowsCommand

          const prompt = this.el.dataset.windowsPrompt || "PS>"

          this.el.dataset.copyText = command

          const promptEl = this.el.querySelector(".install-command__prompt")

          const bodyEl = this.el.querySelector(".install-command__body")

          if (promptEl) promptEl.textContent = prompt

          if (bodyEl) bodyEl.textContent = command

        },

        destroyed() {

          clearTimeout(this.resetTimer)

        }

  """

  use OpenAgentsWeb, :live_view

  @cmd "curl -fsSL https://openagents.com/install.sh | sh"

  @cmd OpenAgentsWeb.CliInstall.unix()

  @windows_cmd OpenAgentsWeb.CliInstall.windows()

  # Three spaces between the frame and the hint, and the hint carries one space

  # of its own on each side, which is the gap the copy confirmation replaces.

     socket

     |> assign(:page_title, "OpenAgents Coder")

     |> assign(:cmd, @cmd)

     |> assign(:windows_cmd, @windows_cmd)

     |> assign(:frame, @frame)}

  end

      id="coder-viewport"

      phx-hook="CoderCopy"

      data-copy-text={@cmd}

      data-unix-command={@cmd}

      data-windows-command={@windows_cmd}

      class="min-h-screen w-full flex flex-col items-center justify-center p-4 select-none cursor-pointer"

      style="background-color: var(--background0, #000); color: var(--foreground0, #fff); font-family: var(--font-family, monospace); -webkit-user-select: none; user-select: none;"

    >

          <:command>

            <Landing.install_command

              id="demo-hero-install-command"

              command="curl -fsSL https://openagents.com/install.sh | sh"

              command={OpenAgentsWeb.CliInstall.unix()}

              windows_command={OpenAgentsWeb.CliInstall.windows()}

            />

          </:command>

          <:note>Every new account starts with $20 of credit.</:note>

      <div class="demo-frame flex justify-center">

        <Landing.install_command

          id="demo-install-command"

          command="curl -fsSL https://openagents.com/install.sh | sh"

          command={OpenAgentsWeb.CliInstall.unix()}

          windows_command={OpenAgentsWeb.CliInstall.windows()}

        />

      </div>

    </div>

  alias OpenAgentsWeb.LiveRefresh

  alias OpenAgentsWeb.UI.Landing

  # The one line the landing page asks a reader to run. It is the command

  # `priv/docs/install-cli.md` documents and the script

  # `priv/static/install.sh` serves, so the page cannot advertise an installer

  # this site does not hand out.

  @install_command "curl -fsSL https://openagents.com/install.sh | sh"

  # The one line the landing page asks a reader to run. Unix pipes

  # `install.sh` into `sh`. Windows PowerShell has no `sh`, so the page

  # swaps to `install.ps1` through `irm | iex` in the browser. Both scripts

  # are served from this site.

  @install_command OpenAgentsWeb.CliInstall.unix()

  @windows_install_command OpenAgentsWeb.CliInstall.windows()

  @feed_limit 8

  @project_limit 6

      {:ok,

       socket

       |> assign(:device_user_code, device_user_code(params))

       |> assign(:install_command, @install_command)}

       |> assign(:install_command, @install_command)

       |> assign(:windows_install_command, @windows_install_command)}

    end

  end

          --%>

          <:command>

            <Landing.install_command id="home-install-command" command={@install_command} />

            <Landing.install_command

              id="home-install-command"

              command={@install_command}

              windows_command={@windows_install_command}

            />

          </:command>

          <%!-- Two lines, not one sentence. The first is what the reader gets

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

  # parser would read them as tags.

  @cli_steps [

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

    %{command: OpenAgentsWeb.CliInstall.unix(), note: "install"},

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

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

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

# Install the OpenAgents CLI

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

The CLI is a single native binary. On macOS and Linux:

```sh

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

```

On Windows, PowerShell has no `sh`, and its `curl` is not the curl that command

names. Run this instead:

```powershell

irm https://openagents.com/install.ps1 | iex

```

The installer detects your operating system and processor, downloads the

matching build, verifies its SHA-256 checksum, and links three names —

`openagents`, `coder`, and `oa` — into `~/.openagents/bin`. It also adds that

openagents --help

```

On Windows PowerShell:

```powershell

irm https://openagents.com/install.ps1 | iex

```

Open a new shell first if the installer has just added `~/.openagents/bin` to

your `PATH`. `openagents --version` reports the installed build, and

`openagents update --check` says what the channel currently names without

# OpenAgents CLI installer for Windows PowerShell.

# https://openagents.com/install.ps1

#

# Usage:

#   irm https://openagents.com/install.ps1 | iex

#

# Optional:

#   $env:OPENAGENTS_CHANNEL = 'stable'

#   $env:OPENAGENTS_VERSION = '0.1.1'

#   $env:OPENAGENTS_BIN_DIR = "$env:USERPROFILE\.openagents\bin"

#

# Do not `exit` from this file. `irm | iex` runs in the reader's PowerShell,

# and `exit` closes that window. Throw instead.

#

# The homepage used to print `curl … | sh`. PowerShell has no `sh`, and its

# `curl` is Invoke-WebRequest, which does not accept `-fsSL`.

$ErrorActionPreference = 'Stop'

$BaseUrl = 'https://openagents.com/releases'

$Channel = if ($env:OPENAGENTS_CHANNEL) { $env:OPENAGENTS_CHANNEL } else { 'stable' }

$HomeDir = if ($env:USERPROFILE) { $env:USERPROFILE } else { $HOME }

$DownloadDir = Join-Path $HomeDir '.openagents\downloads'

$BinDir = if ($env:OPENAGENTS_BIN_DIR) { $env:OPENAGENTS_BIN_DIR } else { Join-Path $HomeDir '.openagents\bin' }

function Test-OpenAgentsVersion([string]$Value) {

    return $Value -match '^[0-9]+\.[0-9]+\.[0-9]+(-[A-Za-z0-9._]+)?$'

}

$Version = $env:OPENAGENTS_VERSION

if (-not $Version) {

    try {

        $Version = (Invoke-RestMethod -Uri "$BaseUrl/$Channel").ToString().Trim()

    } catch {

        throw "Could not resolve the '$Channel' channel from $BaseUrl/$Channel."

    }

}

if (-not (Test-OpenAgentsVersion $Version)) {

    throw "Invalid version format: $Version (expected X.Y.Z or X.Y.Z-suffix)"

}

# Only windows-x86_64 is published. Windows on ARM runs that build.

$Platform = 'windows-x86_64'

$ArtifactUrl = "$BaseUrl/openagents-$Version-$Platform"

$SumsName = "openagents-$Version-$Platform.exe"

New-Item -ItemType Directory -Force -Path $DownloadDir, $BinDir | Out-Null

$Tmp = Join-Path $DownloadDir "openagents-$Platform.exe.tmp"

$Dest = Join-Path $DownloadDir "openagents-$Platform.exe"

Write-Host "Installing OpenAgents CLI v$Version ($Platform)..."

try {

    Invoke-WebRequest -Uri $ArtifactUrl -OutFile $Tmp -UseBasicParsing

} catch {

    if (Test-Path $Tmp) { Remove-Item -Force $Tmp }

    throw "Could not download $ArtifactUrl. No local fallback is used: an installer must install what it says it did."

}

$SumsTmp = "$Tmp.sums"

try {

    Invoke-WebRequest -Uri "$BaseUrl/SHA256SUMS-$Version" -OutFile $SumsTmp -UseBasicParsing

} catch {

    Remove-Item -Force $Tmp, $SumsTmp -ErrorAction SilentlyContinue

    throw "Could not download SHA256SUMS-$Version; refusing to install unverified bytes."

}

$Expected = $null

Get-Content $SumsTmp | ForEach-Object {

    $parts = $_ -split '\s+', 2

    if ($parts.Count -eq 2 -and ($parts[1] -eq $SumsName -or $parts[1] -eq "*$SumsName")) {

        $Expected = $parts[0].ToLowerInvariant()

    }

}

if (-not $Expected) {

    Remove-Item -Force $Tmp, $SumsTmp -ErrorAction SilentlyContinue

    throw "SHA256SUMS-$Version names no entry for $SumsName; refusing to install."

}

$Actual = (Get-FileHash -Algorithm SHA256 -Path $Tmp).Hash.ToLowerInvariant()

if ($Actual -ne $Expected) {

    Remove-Item -Force $Tmp, $SumsTmp -ErrorAction SilentlyContinue

    throw "Checksum mismatch for $SumsName.`n  expected $Expected`n  actual   $Actual"

}

Remove-Item -Force $SumsTmp

Move-Item -Force $Tmp $Dest

Write-Host "  Verified sha256 $Actual."

foreach ($Name in @('openagents', 'coder', 'oa')) {

    Copy-Item -Force $Dest (Join-Path $BinDir "$Name.exe")

}

$UserPath = [Environment]::GetEnvironmentVariable('Path', 'User')

if (-not $UserPath) { $UserPath = '' }

$PathParts = $UserPath -split ';' | Where-Object { $_ -ne '' }

if ($PathParts -notcontains $BinDir) {

    $NewPath = if ($UserPath) { "$BinDir;$UserPath" } else { $BinDir }

    [Environment]::SetEnvironmentVariable('Path', $NewPath, 'User')

    Write-Host "  Added $BinDir to your user PATH."

}

if ($env:Path -notlike "*$BinDir*") {

    $env:Path = "$BinDir;$env:Path"

}

Write-Host ""

Write-Host "OpenAgents v$Version installed."

Write-Host "Open a new terminal, then run: openagents --version"

Write-Host "Loading Coder..."

$Coder = Join-Path $BinDir 'coder.exe'

& $Coder

#   curl -fsSL https://openagents.com/install.sh | sh            # latest stable

#   curl -fsSL https://openagents.com/install.sh | sh -s 0.1.0   # specific version

#

# Windows: run under Git for Windows / MSYS2 Bash; WSL uses the Linux binary.

# Windows PowerShell: irm https://openagents.com/install.ps1 | iex

# Git for Windows / MSYS2 Bash can still run this script; WSL uses the Linux binary.

#

# This is POSIX shell, not bash, and the difference is the point. The musl

# builds exist for Alpine above all, and Alpine ships no bash: piping this into

    # it from the docs run the same installer.

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

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

    assert html =~ "irm https://openagents.com/install.ps1 | iex"

    # `npm i -g @openagentsinc/cli` was a previous answer and is not one now:

    # there is no npm package, and a homepage that prints an install command

    # nothing publishes is worse than one that prints none.

    refute html =~ "npm i -g"

  end

  test "GET /install.ps1 serves the Windows installer", %{conn: conn} do

    conn = get(conn, "/install.ps1")

    assert conn.status == 200

    assert conn.resp_body =~ "irm https://openagents.com/install.ps1 | iex"

    assert conn.resp_body =~ "SHA256SUMS-"

  end

end

    # way to connect the two.

    assert install.markdown =~ "`openagents`, `coder`, and `oa`"

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

    assert install.markdown =~ "irm https://openagents.com/install.ps1 | iex"

    # The page must not send anyone to the npm package. It publishes a *different*

    # program under the same `openagents` name, and having both on one PATH is not

  use ExUnit.Case, async: true

  @script Path.join([File.cwd!(), "priv", "static", "install.sh"])

  @windows_script Path.join([File.cwd!(), "priv", "static", "install.ps1"])

  defp libc(source, arch, root) do

    {output, 0} =

    assert Enum.any?(OpenAgentsWeb.static_prefixes(), &String.starts_with?("install.sh", &1)),

           "no prefix in static_prefixes/0 covers install.sh, so it 404s once digested"

    assert "install.ps1" in OpenAgentsWeb.static_paths(),

           "`install.ps1` is not in static_paths/0, so /install.ps1 is a 404"

    assert Enum.any?(OpenAgentsWeb.static_prefixes(), &String.starts_with?("install.ps1", &1)),

           "no prefix in static_prefixes/0 covers install.ps1, so it 404s once digested"

  end

  test "the script parses" do

    refute body =~ ~r/\[@\]/, "an array expansion is bash-only"

  end

  test "the PowerShell installer refuses unverified bytes and does not exit the shell" do

    script = File.read!(@windows_script)

    assert script =~ "irm https://openagents.com/install.ps1 | iex"

    assert script =~ "SHA256SUMS-"

    assert script =~ "refusing to install unverified bytes"

    assert script =~ "Checksum mismatch"

    body = String.replace(script, ~r/#.*$/m, "")

    # `irm | iex` runs in the reader's PowerShell. `exit` would close it.

    refute body =~ ~r/\bexit\b/,

           "the PowerShell installer must throw, not exit, so irm | iex does not close the window"

  end

  test "nothing is installed without a checksum that matches" do

    script = File.read!(@script)

    {:ok, _view, html} = live(conn, ~p"/coder")

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

    assert html =~ "irm https://openagents.com/install.ps1 | iex"

    # This assertion used to run the other way. The binary release had been

    # withdrawn — artifacts and every channel pointer deleted — so the curl