echo "No local fallback is used: an installer must install what it says it did." >&2

    exit 1

fi

echo "  Downloaded openagents ${version}." >&2

# Verify before the bytes are ever made executable. A checksum fetched over the

# same connection as the artifact proves only that they arrived together, which

rm -f "$sums_tmp"

echo "  Verified sha256 ${actual}." >&2

# This binary installs as `oa` and never as `openagents`.

# Installs three names for one binary: `openagents`, `coder`, and `oa`.

#

# `openagents` is the TypeScript CLI, and it is the one scripts, agent tool

# calls, and the coder's own `openagents` tool invoke by name. This binary

# implements a strict subset of its commands, so taking that name silently

# swaps a fraction of the CLI in underneath everything that calls it, and the

# failure surfaces far from the cause -- `unrecognized subcommand 'reopen'`

# from a script that has always worked. Taking the name is a parity claim, and

# it is not one this binary can make yet. See openagents#90.

#

# A previous version of this installer did take it. Undo that here, and only

# where the link points into our own install -- never touch an `openagents`

# that resolves to something we did not put there.

reclaim_openagents_name() {

    for dir in "$BIN_DIR" "$HOME/.local/bin" "/usr/local/bin"; do

        link="$dir/openagents"

        [ -L "$link" ] || continue

        target="$(readlink "$link" 2>/dev/null || true)"

        case "$target" in

            *"$(basename "$DOWNLOAD_DIR")"/openagents-*|"$BIN_DIR"/oa|"$BIN_DIR"/openagents|../*/openagents-*)

                rm -f "$link" 2>/dev/null || true

                echo "  Removed $link, which shadowed the openagents CLI." >&2

                ;;

        esac

    done

}

# The binary answers both surfaces -- bare it is the coder session, and given a

# command it dispatches to that command -- so `coder` and `openagents` are two

# doors onto the same thing, and `oa` is the short one.

if [ "$os" = "windows" ]; then

    mv -f "$binary_tmp" "$binary_path"

    rm -f "$BIN_DIR/oa.exe.old" 2>/dev/null || true

    cp -f "$binary_path" "$BIN_DIR/oa.exe" 2>/dev/null || true

    rm -f "$BIN_DIR/openagents.exe" 2>/dev/null || true

    echo "  Binary installed to $BIN_DIR/oa.exe." >&2

    for name in openagents coder oa; do

        rm -f "$BIN_DIR/$name.exe.old" 2>/dev/null || true

        cp -f "$binary_path" "$BIN_DIR/$name.exe" 2>/dev/null || true

    done

else

    chmod +x "$binary_tmp"

    mv -f "$binary_tmp" "$binary_path"

    else

        link_target="$binary_path"

    fi

    ln -sf "$link_target" "$BIN_DIR/openagents"

    ln -sf "$link_target" "$BIN_DIR/coder"

    ln -sf "$link_target" "$BIN_DIR/oa"

    reclaim_openagents_name

    echo "  Binary linked to $BIN_DIR/oa." >&2

fi

path_has_dir() {

if [ "$os" != "windows" ] && ! path_has_dir "$BIN_DIR"; then

    for candidate in "$HOME/.local/bin" "/usr/local/bin"; do

        if path_has_dir "$candidate" && [ -d "$candidate" ] && [ -w "$candidate" ]; then

            ln -sf "$BIN_DIR/openagents" "$candidate/openagents"

            ln -sf "$BIN_DIR/coder" "$candidate/coder"

            ln -sf "$BIN_DIR/oa" "$candidate/oa"

            SYMLINK_CREATED="$candidate"

            echo "  Symlinked $candidate/oa -> $BIN_DIR/oa" >&2

            break

        fi

    done

    echo "  Updated $BIN_DIR in PATH in $config_file." >&2

fi

# Tell people when `oa` will not run what we just installed.

#

# Two ways that happens, and the installer can see both:

#

#   1. Another `oa` sits earlier on PATH.

#   2. A shell alias or function named `oa` is defined in the rc file. This one

#      is nastier: aliases and functions beat PATH in an interactive shell, the

#      installer runs non-interactively so `command -v oa` cannot see them, and

#      nothing about the running binary says which one answered. Grepping the

#      rc file is the only way to catch it from here.

#

# Report, never edit. The alias may be deliberate, and silently rewriting

# someone's shell config is worse than the shadowing.

CONFLICTS=""

installed_oa="$BIN_DIR/oa"

[ "$os" = "windows" ] && installed_oa="$BIN_DIR/oa.exe"

resolved_oa="$(command -v oa 2>/dev/null || true)"

if [ -n "$resolved_oa" ]; then

    resolved_real="$(cd "$(dirname "$resolved_oa")" 2>/dev/null && pwd -P)/$(basename "$resolved_oa")"

    installed_real="$(cd "$(dirname "$installed_oa")" 2>/dev/null && pwd -P)/$(basename "$installed_oa")"

    if [ -n "$SYMLINK_CREATED" ] && [ "$resolved_real" = "$SYMLINK_CREATED/oa" ]; then

        : # our own symlink, which points at the binary we just installed

    elif [ "$resolved_real" != "$installed_real" ]; then

        CONFLICTS="yes"

        echo "" >&2

        echo "WARNING: 'oa' on your PATH is not what this installer just wrote." >&2

        echo "  PATH resolves oa to: $resolved_oa" >&2

        echo "  Installed here:      $installed_oa" >&2

    fi

fi

if [ -n "$config_file" ] && [ -f "$config_file" ]; then

    if grep -Eqs '^[[:space:]]*(alias[[:space:]]+oa=|oa[[:space:]]*\(\)|function[[:space:]]+oa\b)' "$config_file"; then

        CONFLICTS="yes"

        echo "" >&2

        echo "WARNING: $config_file defines a shell alias or function named 'oa'." >&2

        echo "  It takes precedence over PATH, so typing 'oa' will not run the" >&2

        echo "  binary this installer wrote, and nothing in the output will say so." >&2

        echo "  Remove it, rename it, or run $installed_oa by its full path." >&2

        grep -Ens '^[[:space:]]*(alias[[:space:]]+oa=|oa[[:space:]]*\(\)|function[[:space:]]+oa\b)' "$config_file" \

            | sed 's/^/    /' >&2

    fi

fi

echo "" >&2

echo "OpenAgents CLI $version installation complete!" >&2

if [ -n "$CONFLICTS" ]; then

    echo "Run '$installed_oa --version' to confirm which build answers." >&2

else

    echo "Run 'oa' to get started." >&2

fi

echo "" >&2

echo "Note: this installs 'oa' only. The 'openagents' command is the separate" >&2

echo "TypeScript CLI (npm i -g @openagentsinc/cli) and is left alone." >&2

echo "OpenAgents $version installed. Run 'openagents' to start." >&2

           "the installer never reads the channel pointer"

  end

  # The Rust binary implements a strict subset of the TypeScript CLI's

  # commands, so taking the `openagents` name swaps a fraction of the CLI in

  # underneath every script, agent tool call, and `openagents` tool that

  # invokes it by name — and the failure surfaces far from the cause, as

  # `unrecognized subcommand` from something that always worked. See

  # openagents#90.

  #

  # These run the installer's own shell, rather than grepping it. A test that

  # only greps passes the moment someone writes the same bug a different way.

  describe "the `openagents` name" do

    test "is never written by an install" do

  describe "the name it installs" do

    # This reverses the `oa`-only rule. That rule existed because the Rust

    # binary answered a strict subset of the CLI's commands, so taking the

    # `openagents` name swapped a fraction of the CLI in underneath every

    # script that called it. That is no longer true: the shipped binary

    # dispatches the whole command set and is the coder session besides.

    test "installs openagents, coder, and oa for the same binary" do

      script = File.read!(@script)

      refute script =~ ~s(ln -sf "$link_target" "$BIN_DIR/openagents"),

             "the installer links the openagents name at the Rust binary"

      assert script =~ ~s(ln -sf "$link_target" "$BIN_DIR/openagents"),

             "the installer does not create the openagents name"

      refute script =~ ~s($candidate/openagents),

             "the installer puts the openagents name on PATH"

    end

    test "is reclaimed when an earlier install took it, and only then" do

      tmp = Path.join(System.tmp_dir!(), "oa-reclaim-#{System.unique_integer([:positive])}")

      bin = Path.join(tmp, "bin")

      downloads = Path.join(tmp, "downloads")

      File.mkdir_p!(bin)

      File.mkdir_p!(downloads)

      binary = Path.join(downloads, "openagents-macos-aarch64")

      File.write!(binary, "#!/bin/sh\n")

      # What a previous install left behind, and what must go.

      File.ln_s!("../downloads/openagents-macos-aarch64", Path.join(bin, "openagents"))

      # Someone else's `openagents`, which must survive untouched.

      other = Path.join(tmp, "real-openagents")

      File.write!(other, "#!/bin/sh\n")

      File.ln_s!(other, Path.join(bin, "openagents-real"))

      script = File.read!(@script)

      # The function working proves nothing if the install path never calls it.

      assert script =~ ~r/^\s+reclaim_openagents_name$/m,

             "reclaim_openagents_name is defined and never called"

      body = extract_function(script, "reclaim_openagents_name")

      assert script =~ ~s(ln -sf "$link_target" "$BIN_DIR/coder"),

             "the installer does not create the coder name"

      runner = Path.join(tmp, "run.sh")

      File.write!(runner, """

      BIN_DIR="#{bin}"

      DOWNLOAD_DIR="#{downloads}"

      HOME="#{tmp}"

      #{body}

      reclaim_openagents_name

      """)

      assert {_out, 0} = System.cmd("sh", [runner], stderr_to_stdout: true)

      refute File.exists?(Path.join(bin, "openagents")),

             "the link an earlier install left is still shadowing the CLI"

      assert File.exists?(Path.join(bin, "openagents-real")),

             "an openagents we did not install was removed"

      assert File.exists?(binary), "the binary itself was removed with the link"

      File.rm_rf!(tmp)

      assert script =~ ~s(ln -sf "$link_target" "$BIN_DIR/oa"),

             "the installer does not create the oa alias"

    end

    test "a shell alias named oa is reported, since it beats PATH and is invisible to `command -v`" do

      pattern = shadow_pattern(File.read!(@script))

      tmp = Path.join(System.tmp_dir!(), "oa-rc-#{System.unique_integer([:positive])}")

      File.mkdir_p!(tmp)

      rc = Path.join(tmp, "rc")

      File.write!(rc, """

      export PATH="/usr/bin:$PATH"

      alias oa="node ~/old/cli.js"

      alias oat="a different command"

      oa() { echo hi; }

      function oa { echo hi; }

      alias openagents="not this one"

      # alias oa=commented out

      """)

    test "says one line about what it installed, and names openagents" do

      script = File.read!(@script)

      {out, _} = System.cmd("sh", ["-c", "grep -Ens '#{pattern}' '#{rc}' || true"])

      assert script =~ ~s(OpenAgents $version installed. Run 'openagents' to start.)

      lines =

        out |> String.split("\n", trim: true) |> Enum.map(&List.first(String.split(&1, ":")))

      # The closing block used to carry a shadow warning, a PATH comparison and

      # a note about a different CLI. It was noise on a successful install.

      refute script =~ "TypeScript CLI",

             "the installer talks about a different CLI"

      assert lines == ["2", "4", "5"],

             "the shadow check found #{inspect(lines)}; it must catch the three ways `oa` is " <>

               "defined and leave `oat`, `openagents`, and a comment alone"

      refute script =~ "npm i -g",

             "the installer sends the reader somewhere else"

      File.rm_rf!(tmp)

      refute script =~ "installs 'oa' only",

             "the installer still claims it installs oa only"

    end

  end