},

  copy() {

    const text = this.el.dataset.copyText || "npm i -g @openagentsinc/cli"

    const text = this.el.dataset.copyText || "curl -fsSL https://openagents.com/install.sh | sh"

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

    // The hint sits inside a box drawn in text, so the confirmation has to

    // occupy exactly the columns the command did or the frame loses a side

    // for two seconds. Centred by measurement rather than by hand-counted

    // spaces, which is what went stale the last time the command changed.

    const centre = (label, width) => {

      const pad = Math.max(0, width - label.length)

      const left = Math.floor(pad / 2)

      return " ".repeat(left) + label + " ".repeat(pad - left)

    }

    const flashCopied = () => {

      if (hintEl) {

        hintEl.textContent = "    copied to clipboard!     "

        const width = text.length + 2

        hintEl.textContent = centre("copied to clipboard!", width)

        clearTimeout(this._timeout)

        this._timeout = setTimeout(() => {

          hintEl.textContent = " " + text + " "

  that needs a second one needs a decision rather than an escape hatch. The

  colours come from the CSS variables that system already defines, with literal

  fallbacks, which is what the page was really relying on.

  The command it prints is the installer. `@openagentsinc/cli` is a different

  program answering to the same name, and this page was the last surface still

  handing it out.

  The frame is built rather than typed, and the command sets its width rather

  than being fitted into it. Typed, it was significant whitespace inside a

  template: the box was drawn for a 49-column interior, the command row came to

  35, and the box had been rendering with one short side since long before the

  command changed. `phx-no-format` does not save a typed box either — the HEEx

  formatter re-indents the text inside a multi-line tag whichever way that

  attribute is set, which puts four spaces down the left of every row but the

  first. Composed here, the padding is arithmetic against one interior width and

  the template holds a single interpolation.

  """

  use OpenAgentsWeb, :live_view

  @cmd "npm i -g @openagentsinc/cli"

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

  # 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.

  @outer 3

  @interior @outer + String.length(@cmd) + 2 + @outer

  # The wordmark and the two noise rows were drawn for a 49-column interior.

  # Each keeps the padding it was drawn with and gains the difference.

  @drawn_for 49

  @side div(@interior - @drawn_for, 2)

  @wordmark [

    {5, "██████╗ ██████╗ ██████╗ ███████╗██████╗", 5},

    {4, "██╔════╝██╔═══██╗██╔══██╗██╔════╝██╔══██╗", 4},

    {4, "██║     ██║   ██║██║  ██║█████╗  ██████╔╝", 4},

    {4, "██║     ██║   ██║██║  ██║██╔══╝  ██╔══██╗", 4},

    {4, "╚██████╗╚██████╔╝██████╔╝███████╗██║  ██║", 4},

    {5, "╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝", 4}

  ]

  @noise_top "000111011001000110000101001000101000010000101100010110010"

  @noise_bottom "111110001011000001010000000000001000100110001110101101001"

  @dim ~s|<span style="color: var(--foreground2, #666);">|

  @cyan ~s|<span class="font-bold text-cyan-400" style="color: #56b6c2;">|

  @close "</span>"

  @title " OpenAgents "

  @rule @interior - String.length(@title)

  @frame Enum.join(

           [

             @dim <>

               "┌" <>

               String.duplicate("─", div(@rule, 2)) <>

               @close <>

               @title <>

               @dim <> String.duplicate("─", @rule - div(@rule, 2)) <> "┐" <> @close,

             @dim <> "│" <> @close <> @noise_top <> @dim <> "│" <> @close,

             @dim <> "│" <> String.duplicate(" ", @interior) <> "│" <> @close

           ] ++

             Enum.map(@wordmark, fn {lead, glyphs, trail} ->

               @dim <>

                 "│" <>

                 @close <>

                 String.duplicate(" ", lead + @side) <>

                 @cyan <>

                 glyphs <>

                 @close <>

                 String.duplicate(" ", trail + @side) <> @dim <> "│" <> @close

             end) ++

             [

               @dim <> "│" <> String.duplicate(" ", @interior) <> "│" <> @close,

               @dim <>

                 "│" <>

                 @close <>

                 String.duplicate(" ", @outer) <>

                 ~s|<span id="copy-hint" style="color: var(--foreground1, #ccc);"> | <>

                 @cmd <>

                 " " <>

                 @close <>

                 String.duplicate(" ", @outer) <> @dim <> "│" <> @close,

               @dim <> "│" <> @close <> @noise_bottom <> @dim <> "│" <> @close,

               @dim <> "└" <> String.duplicate("─", @interior) <> "┘" <> @close

             ],

           "\n"

         )

  @impl true

  def mount(_params, _session, socket) do

    {:ok,

     socket

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

     |> assign(:cmd, @cmd)}

     |> assign(:cmd, @cmd)

     |> assign(:frame, @frame)}

  end

  @impl true

        <pre

          class="font-mono text-xs sm:text-sm md:text-base leading-none select-none pointer-events-none"

          style="margin: 0; color: var(--foreground0, #fff); -webkit-user-select: none; user-select: none;"

        >

          <span style="color: var(--foreground2, #666);">┌──────────────────</span> OpenAgents <span style="color: var(--foreground2, #666);">───────────────────┐</span>

          <span style="color: var(--foreground2, #666);">│</span>0001110110010001100001010010001010000100001011000<span style="color: var(--foreground2, #666);">│</span>

          <span style="color: var(--foreground2, #666);">│                                                 │</span>

          <span style="color: var(--foreground2, #666);">│</span>     <span class="font-bold text-cyan-400" style="color: #56b6c2;">██████╗ ██████╗ ██████╗ ███████╗██████╗</span>     <span style="color: var(--foreground2, #666);">│</span>

          <span style="color: var(--foreground2, #666);">│</span>    <span class="font-bold text-cyan-400" style="color: #56b6c2;">██╔════╝██╔═══██╗██╔══██╗██╔════╝██╔══██╗</span>    <span style="color: var(--foreground2, #666);">│</span>

          <span style="color: var(--foreground2, #666);">│</span>    <span class="font-bold text-cyan-400" style="color: #56b6c2;">██║     ██║   ██║██║  ██║█████╗  ██████╔╝</span>    <span style="color: var(--foreground2, #666);">│</span>

          <span style="color: var(--foreground2, #666);">│</span>    <span class="font-bold text-cyan-400" style="color: #56b6c2;">██║     ██║   ██║██║  ██║██╔══╝  ██╔══██╗</span>    <span style="color: var(--foreground2, #666);">│</span>

          <span style="color: var(--foreground2, #666);">│</span>    <span class="font-bold text-cyan-400" style="color: #56b6c2;">╚██████╗╚██████╔╝██████╔╝███████╗██║  ██║</span>    <span style="color: var(--foreground2, #666);">│</span>

          <span style="color: var(--foreground2, #666);">│</span>     <span class="font-bold text-cyan-400" style="color: #56b6c2;">╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝</span>    <span style="color: var(--foreground2, #666);">│</span>

          <span style="color: var(--foreground2, #666);">│                                                 │</span>

          <span style="color: var(--foreground2, #666);">│</span>   <span id="copy-hint" style="color: var(--foreground1, #ccc);"> <%= @cmd %> </span>   <span style="color: var(--foreground2, #666);">│</span>

          <span style="color: var(--foreground2, #666);">│</span>1111100010110000010100000000000010001001100011101<span style="color: var(--foreground2, #666);">│</span>

          <span style="color: var(--foreground2, #666);">└─────────────────────────────────────────────────┘</span>

        </pre>

        >{raw(@frame)}</pre>

      </div>

    </div>

    """

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

  # parser would read them as tags.

  @cli_steps [

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

    %{command: "curl -fsSL https://openagents.com/install.sh | sh", 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 CLI and sign in to the profile you intend to use:

```sh

npm install --global @openagentsinc/cli@latest

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

openagents auth login

openagents auth status

```

openagents <subcommand> [flags]

```

`openagents`, `coder`, and `oa` are three names for one binary, so every

command on this page runs under any of them. Run it bare and it starts a coder

session instead. See [Install the CLI](/docs/install-cli).

Run `openagents <command> --help` for the reference that matches your installed

version. When you use `npx`, replace the `openagents` prefix with

`npx --yes @openagentsinc/cli@latest`.

version.

## Use global flags

```sh

openagents --profile staging --json repo list

npx --yes @openagentsinc/cli@latest --profile staging --json repo list

oa --profile staging --json repo list

```

Setting `NO_COLOR` also disables ANSI output.

`auth git-credential` is an internal Git-helper endpoint. Do not invoke it

directly.

Do not run either `auth setup-git` form through `npx`. Install the CLI globally

before you save a persistent helper configuration.

## Create a repository

```text

## Know which commands are unavailable

This release does not provide named `issue` or `project` commands, repository

mirroring, pull-request commands, ruleset commands, SSH-key commands, or a

self-update command. Use `openagents api` for the implemented Issues and

Projects routes, and use only commands shown by the installed version's

`--help` output.

mirroring, pull-request commands, ruleset commands, or SSH-key commands. Use

`openagents api` for the implemented Issues and Projects routes, and use only

commands shown by the installed version's `--help` output.

## Update the binary

`openagents update` resolves the release channel, compares the version it names

against the running binary, and replaces the binary in place when they differ.

`openagents self-update` is the same command. See

[Install the CLI](/docs/install-cli) for channels, pinned versions, and what

the update verifies.

## Next steps

openagents repo clone OWNER/REPOSITORY ./local-directory

```

For a one-time clone without a global installation:

```sh

npx --yes @openagentsinc/cli@latest repo clone OWNER/REPOSITORY

```

The command retrieves the server-provided clone URL and invokes Git without

putting the token in the URL or process arguments. It scopes the OpenAgents

credential helper to the selected API origin for that clone process.

Public repositories support anonymous clone and fetch. Private repositories

require an authorized credential.

Before you use standard Git with a private repository, install the CLI globally

and configure the helper in the worktree:

Before you use standard Git with a private repository, configure the helper in

the worktree:

```sh

npm install --global @openagentsinc/cli

cd existing-worktree

openagents auth setup-git --local

```

Do not run `auth setup-git` through `npx`. The saved helper calls

`openagents`, and the temporary `npx` executable is unavailable after that

command exits.

The helper configuration refers to the `openagents` executable by path, so

install it where it stays: the installer links it into `~/.openagents/bin` and

puts that directory on your `PATH`.

Use global setup only when you want every local repository to use the helper

for the selected OpenAgents origin:

writes the current lifecycle state, elapsed time, and a five-second heartbeat

to standard error.

For one command without a global install, prefix the same arguments with the

package name:

```sh

npx --yes @openagentsinc/cli@latest repo create my-project

```

## Attach an existing local project

Create the remote repository and attach it to an existing Git worktree:

## Push the first commit

Install the CLI globally before configuring persistent Git authentication:

Configure persistent Git authentication in the worktree, then push:

```sh

npm install --global @openagentsinc/cli

cd existing-worktree

openagents auth setup-git --local

git push -u origin HEAD

openagents repo delete OWNER/REPOSITORY --yes

```

You can run the same one-time command through `npx`:

```sh

npx --yes @openagentsinc/cli@latest repo delete OWNER/REPOSITORY --yes

```

The command also supports `--repo OWNER/REPOSITORY`. When you omit the name,

the CLI infers it from an exact OpenAgents `origin` remote.

`--wait-timeout 0` to return after the server accepts the durable import.

A client timeout does not cancel the server-side import.

## Import once with npx

## Pin a version for a qualification run

Run the same import without a global installation:

A release channel is a pointer that moves, so an import you run today and the

same import next month can run under different builds. Install one exact

version when a qualification run has to stay reproducible:

```sh

npx --yes @openagentsinc/cli@latest repo import OWNER/REPOSITORY

```

Pin the package version for a reproducible qualification run:

```sh

npx --yes @openagentsinc/cli@0.2.1 \

  --profile staging \

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

openagents --profile staging \

  repo import OWNER/REPOSITORY \

  --private \

  --wait-timeout 300

```

You can use `npx` for the import and the CLI-managed clone. Install the CLI

globally before you run `auth setup-git`, because a persistent Git helper

cannot call the temporary executable after `npx` exits.

## Import from a headless agent

In a headless agent process, start the resumable login before the import:

In a headless process, start the resumable login before the import:

```sh

npx --yes @openagentsinc/cli@latest --json auth login

openagents --json auth login

# The agent shows you the URL and code. After you approve the request:

npx --yes @openagentsinc/cli@latest --json auth login --resume

openagents --json auth login --resume

```

The first command returns immediately, so the agent does not need streaming

shell output.

shell output. The agent never receives your GitHub credential or the issued

OpenAgents token.

## Import a large repository

# The OpenAgents CLI

`openagents` is the OpenAgents command-line interface, distributed on npm as

`@openagentsinc/cli`. It signs you in, configures Git authentication, manages

[repositories](/docs/repositories) from a terminal, and calls implemented API

routes such as Issues and Projects.

`openagents` is the OpenAgents command-line interface. It signs you in,

configures Git authentication, manages [repositories](/docs/repositories) from

a terminal, and calls implemented API routes such as Issues and Projects.

It is one native binary, installed under three names. `openagents` and `coder`

are two doors onto the same program, and `oa` is the short one. Run it bare and

it starts a coder session; give it a command and it runs that command. This

page covers the command surface. See [Install the CLI](/docs/install-cli) for

the installer, release channels, and where the binary lands.

## What the CLI does

- Install a Git credential helper scoped to the selected OpenAgents origin.

- Create, import, list, view, clone, and delete repositories.

- Wait on durable provisioning and import state machines.

- Read and post on the [forum](/docs/forum) from a terminal.

- Call Issues, Projects, and other API routes with `openagents api`.

- Replace itself with a newer build with `openagents update`.

- Use JSON output and stable exit codes in scripts and agents.

The CLI does not provide named `issue` or `project` commands, pull request

commands, continuous GitHub mirroring, SSH transport, rulesets, or a

self-update command. Use `openagents api` for the routes that have no named

command yet.

## Choose how to run the CLI

commands, continuous GitHub mirroring, SSH transport, or rulesets. Use

`openagents api` for the routes that have no named command yet.

Install the CLI globally when you use it regularly or when you want to

configure Git authentication that remains available after the current command:

## Install and check

```sh

npm install --global @openagentsinc/cli

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

openagents --help

```

Use `npx` for one command without a global installation:

```sh

npx --yes @openagentsinc/cli@latest --help

npx --yes @openagentsinc/cli@latest repo list

```

Do not configure a persistent Git credential helper through `npx`. The helper

configuration refers to the `openagents` executable, but the temporary `npx`

executable disappears when the command ends. Install the CLI globally before

you run `openagents auth setup-git --local` or

`openagents auth setup-git --global --yes`.

See [Install the CLI](/docs/install-cli) for authentication, profiles,

configuration, and the complete `npx` guidance.

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

installing anything.

## Follow a common terminal workflow

1. Install and sign in:

   ```sh

   npm install --global @openagentsinc/cli

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

   openagents auth login

   openagents auth status

   ```

Run `openagents auth login` to start a browser-assisted device flow. You review

and approve that request while signed in to the site. The CLI receives an

OpenAgents API token, not your GitHub token. See [Install the

CLI](/docs/install-cli) for npm and `npx` instructions.

CLI](/docs/install-cli) for the installer, release channels, and where the

binary lands.

In a headless process, the command returns the authorization URL and user code

immediately. After you approve the request, the agent runs `openagents auth

defmodule OpenAgentsWeb.InstallPathTest do

  @moduledoc """

  One way to install, said the same way everywhere a reader is told to.

  `@openagentsinc/cli` is a different program answering to the same name as the

  binary this site serves, and having both on one `PATH` broke `git push`

  machine-wide. The install command moved to `install.sh`, but nine

  documentation pages and two application surfaces went on handing out the npm

  package for long enough that the homepage ended up contradicting the

  documentation it links to (issue #260).

  These assertions read what a reader is actually shown, not what the source

  says about it: the Markdown that becomes a documentation page, and the HTML

  the two install-bearing LiveViews render. A module comment may name the npm

  package -- explaining why it is gone is not offering it -- and this test must

  not turn that into a failure.

  """

  use OpenAgentsWeb.ConnCase, async: true

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

  # `npm` alone is too broad: several moduledocs use "pnpm, not npm" as the

  # worked example of a memory whose words do not appear in the request it has

  # to reach. These are the forms that install something.

  @offers_npm ~r{npm i -g|npm install|npx |@openagentsinc/cli}

  test "no documentation page offers npm as a way to install" do

    offenders =

      for path <- Path.wildcard("priv/docs/**/*.md"),

          matches = Regex.scan(@offers_npm, File.read!(path)),

          matches != [],

          do: {Path.relative_to_cwd(path), matches |> List.flatten() |> Enum.uniq()}

    assert offenders == [],

           """

           These documentation pages still offer the npm package:

           #{Enum.map_join(offenders, "\n", fn {path, found} -> "  #{path}: #{Enum.join(found, ", ")}" end)}

           The one install path is `#{@command}`. See /docs/install-cli.

           """

  end

  test "at least one documentation page prints the installer, so this test can fail" do

    # Without this, deleting every mention of installing anything would pass the

    # assertion above while leaving a reader with no way in.

    printed? =

      Enum.any?(Path.wildcard("priv/docs/**/*.md"), &String.contains?(File.read!(&1), @command))

    assert printed?, "no documentation page prints #{@command}"

  end

  test "the coder page prints the installer and not the npm package", %{conn: conn} do

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

    assert html =~ @command

    refute html =~ @offers_npm

  end

  test "the repository list prints the installer and not the npm package", %{conn: conn} do

    html =

      conn

      |> log_in_github_user("install-path-repository-list")

      |> get(~p"/repositories")

      |> html_response(200)

    assert html =~ @command

    refute html =~ @offers_npm

  end

end

  test "the page offers the published install command", %{conn: conn} do

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

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

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

    # The binary release was withdrawn — artifacts and every channel pointer

    # deleted — so the curl command can only fail, and the build it installed

    # printed fabricated data. Offering it is worse than offering nothing.

    refute html =~ "install.sh"

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

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

    # command could only fail, and `npm i -g @openagentsinc/cli` was what the

    # page handed out instead. The release is back, `install.sh` is what the

    # documentation and the homepage publish, and the npm package is a

    # different program answering to the same name: two of them on one `PATH`

    # broke `git push` machine-wide (issue #260).

    refute html =~ "@openagentsinc/cli"

  end

  test "every row of the frame is the same width", %{conn: conn} do

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

    # The box is drawn in text, so a row that does not match the others shows

    # as a broken side. It was typed for a 49-column interior while the command

    # row came to 35, and nothing noticed until the command changed length.

    # It is composed from the command now, and this is what holds that.

    [frame] = Regex.run(~r{<pre[^>]*>(.*?)</pre>}s, html, capture: :all_but_first)

    widths =

      frame

      |> String.replace(~r{<[^>]+>}, "")

      |> String.split("\n")

      |> Enum.map(&String.length/1)

      |> Enum.uniq()

    assert length(widths) == 1, "frame rows differ in width: #{inspect(widths)}"

  end

  test "the page adds no stylesheet of its own", %{conn: conn} do

    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 =~ "npm i -g @openagentsinc/cli"

    refute html =~ "install.sh"

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

    refute html =~ "@openagentsinc/cli"

    assert html =~ "openagents auth login"

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

    assert html =~ "/<owner>/<name>.git"