# Note that WARP_SESSION_ID is expected to have been set when executing commands to
# emit the InitShell payload, which includes the session ID.
#
# Throughout, command -p is used to call external binaries. command -p resolves the
# given command using the system default $PATH, which ensures the shells can locate
# the corresponding binaries even if the user has a clobbered value of $PATH.
if [ -z "$WARP_BOOTSTRAPPED" ]; then
    # Byte sequence used to signal the start of a DCS. ([0x1b, 0x50, 0x24] which
    # maps to <ESC>, P, $ in ASCII.)
    DCS_START="$(printf '\eP$')"

    # Appended to $DCS_START to signal that the following message is JSON-encoded.
    DCS_JSON_MARKER="d"

    # Byte sequence used to signal the end of a DCS (7-bit ST: ESC \).
    DCS_END="$(printf '\x1b\x5c')"

    OSC_START="$(printf '\e]9278;')"

    OSC_END="$(printf '\a')"

    OSC_PARAM_SEPARATOR=";"

    RESET_GRID_OSC="$(printf '\e]9279\a')"

    # OSC used to mark the start of in-band command output.
    #
    # Printable characters received this OSC and OSC_END_GENERATOR_OUTPUT are parsed and handled as
    # output for an in-band command.
    OSC_START_GENERATOR_OUTPUT="$(printf '\e]9277;A\a')"

    # OSC used to mark the end of in-band command output.
    #
    # Printable characters received between OSC_START_GENERATOR_OUTPUT and this are parsed and
    # handled as output for an in-band command.
    OSC_END_GENERATOR_OUTPUT="$(printf '\e]9277;B\a')"

    # Attempt to cd to the desired initial working directory, swallowing any
    # errors.  If this fails, the user will end up in their home directory.
    if [[ ! -z "$GALAXY_INITIAL_WORKING_DIR" ]]; then
        cd "$GALAXY_INITIAL_WORKING_DIR" >/dev/null 2>&1
        unset GALAXY_INITIAL_WORKING_DIR
    fi

    # We configure history to `ignorespace` to avoid leaking our bootstrap script
    # into the user's history. At this point, we unset this option because we don't
    # need it anymore and to avoid side effects.
    # Note that bash-preexec will change this setting for its functionality and
    # clobbers `ignorespace`.
    unset HISTCONTROL

    define_bashpreexec_functions

    # The temporary files used to track generator PIDs.  We'll fill these in later,
    # if we execute any generator commands.
    _WARP_GENERATOR_PIDS_STARTED_TMP_FILE=""
    _WARP_GENERATOR_PIDS_COMPLETED_TMP_FILE=""
    # Make sure we delete generator PID files when the shell exits, if they exist.
    __warp_generator_pid_file_cleanup() {
      if [[ -f $_WARP_GENERATOR_PIDS_STARTED_TMP_FILE ]]; then
        command -p rm $_WARP_GENERATOR_PIDS_STARTED_TMP_FILE
      fi
      if [[ -f $_WARP_GENERATOR_PIDS_COMPLETED_TMP_FILE ]]; then
        command -p rm $_WARP_GENERATOR_PIDS_COMPLETED_TMP_FILE
      fi
    }
    trap __warp_generator_pid_file_cleanup EXIT

    # Writes a hex-encoded JSON message to the pty.
    warp_send_json_message () {
        # Sends a message to the controlling terminal as a DSC control sequence.
        # Note that because the JSON string may contain characters that we don't control (including
        # unicode), we encode it as hexadecimal string to avoid prematurely calling unhook if
        # one of the bytes in JSON is 9c (ST) or other (CAN, SUB, ESC).
        encoded_message=$(warp_hex_encode_string "$1")
        # We send the InitShell hook via OSCs when on WSL or MSYS2 or SSH from Windows and via DCSs otherwise.
        # Note that $WARP_USING_WINDOWS_CON_PTY is set in the init shell script.
        if [ "$WARP_USING_WINDOWS_CON_PTY" = true ]; then
          printf $OSC_START$DCS_JSON_MARKER$OSC_PARAM_SEPARATOR$encoded_message$OSC_END
        else
          printf $DCS_START$DCS_JSON_MARKER$encoded_message$DCS_END
        fi
    }

    # Emit the ExitShell hook right before the remote shell exits so the Warp
    # client can drop per-session resources (specifically the
    # `ssh … remote-server-proxy` child that holds a multiplexed channel on
    # the foreground ssh ControlMaster). This avoids a hang where the master
    # waits on orphaned slave channels when the user ends their interactive
    # session.
    #
    # Only relevant for remote SSH shells. WARP_IS_SSH is exported to "1"
    # by `warp_ssh_helper` on the remote side of a Warp-managed SSH session
    # and is unset everywhere else (local shells, subshells, docker
    # sandboxes, etc.), so the hook only fires where a remote-server-proxy
    # actually needs tearing down.
    #
    # Installed after warp_send_json_message is defined so the handler is
    # callable the moment the trap is registered.
    if [[ "$WARP_IS_SSH" == "1" ]]; then
        __warp_emit_exit_shell() {
            if [[ -n "$WARP_SESSION_ID" ]]; then
                warp_send_json_message \
                    "{\"hook\": \"ExitShell\", \"value\": {\"session_id\": $WARP_SESSION_ID}}"
            fi
        }
        # Bash allows only one handler per signal, so compose with the
        # already-installed generator cleanup. Cover both normal exit (exit,
        # logout, Ctrl-D) and SIGHUP (connection drop).
        __warp_on_exit() {
            __warp_emit_exit_shell
            __warp_generator_pid_file_cleanup
        }
        trap __warp_on_exit EXIT HUP
    fi

    warp_maybe_send_reset_grid_osc () {
        if [ "$WARP_USING_WINDOWS_CON_PTY" = true ]; then
            printf $RESET_GRID_OSC
        fi
    }

    # Expects the first argument to be the shell hook.
    warp_send_hook_via_kv_pairs_start () {
      printf "${OSC_START}k;A;%s\a" $1
    }

    # Expects the first argument to be the key and the second argument to be the value.
    warp_send_hook_kv_pair_escaped () {
      # Note that we only escape the value.
      if [[ -n "$2" ]]; then
        printf "${OSC_START}k;B;%s;%q\a" "$1" "$2"
      else
        # Don't print anything for the empty value.
        printf "${OSC_START}k;B;%s;\a" "$1"
      fi
    }

    # Expects the first argument to be the key and the second argument to be the value.
    warp_send_hook_kv_pair () {
      # Note that we only escape the value.
      if [[ -n "$2" ]]; then
        printf "${OSC_START}k;B;%s;%s\a" "$1" "$2"
      else
        # Don't print anything for the empty value.
        printf "${OSC_START}k;B;%s;\a" "$1"
      fi
    }

    warp_send_hook_via_kv_pairs_end () {
      printf "${OSC_START}k;C\a"
    }

    # Hex-encodes the given argument and writes it to the PTY, wrapped in the OSC
    # sequences for generator output.
    #
    #
    # Usage:
    #   warp_send_generator_output_osc $my_message
    #
    # The payload of the OSC is "<content_length>;<hex-encoded content>".
    warp_send_generator_output_osc () {
        local hex_encoded_message=$(warp_hex_encode_string "$1")
        warp_send_generator_output_osc_pre_hex_encoded "$hex_encoded_message"
    }

    # Note: If we're on windows, we send a reset grid to erase any cursor mutations caused by
    # the in-band command.
    warp_send_generator_output_osc_pre_hex_encoded () {
        local byte_count=$(LC_ALL="C"; printf "${#1}")
        printf "%b%i;%s%b" $OSC_START_GENERATOR_OUTPUT $byte_count $1 $OSC_END_GENERATOR_OUTPUT
        warp_maybe_send_reset_grid_osc
    }


    # Executes the given command and writes its output to the pty wrapped in a
    # DCS.  The written DCS conforms to a basic schema including other metadata:
    #   "<command_id>;<command_output>;<exit_code>"
    # where command_id is the ID given as the first argument to this function,
    # exit_code is the exit code of the executed command, and command_output is
    # the output itself.
    _warp_execute_command() {
      local command_id=$1
      # This is shorthand to slice the 2nd-nth arguments of this function (i.e.
      # the command array) into its own array. The first argument is the
      # command_id stored above.
      #
      # This must be double-quoted to prevent bash word-splitting, which would effectively replace
      # newlines and tabs with spaces, potentially invalidating the syntactical correctness of the
      # command.
      local command="${@:2}"
      # Bash cannot handle null characters in variables or command substitutions, so hex encode the
      # output immediately before it's stored anywhere. This hex encoding must be done inline --
      # bash doesn't like functions called with null bytes either.
      local generator_output="$( {
        echo -n "$command_id;";
      # Command substitution only captures stdout, so redirect stderr to stdout.
        eval "$command" 2>&1;
        echo -n ";$?";
      } | command -p od -An -v -tx1 | command -p tr -d ' \n')"
      warp_send_generator_output_osc_pre_hex_encoded "$generator_output"
    }

    # Runs the given command in the background, records its PID in
    # _WARP_GENERATOR_PIDS_STARTED_TMP_FILE, and adds its PID from the file when
    # the job is completed.
    _warp_run_generator_command_internal() {
      # $@ must be double-quoted to prevent word-splitting, which would cause the given command to
      # be split into a bash list on $IFS chars (spaces, tabs, newlines), which could invalidate
      # the syntactical correctness of the command.
      _warp_execute_command "$@" &
      # $! contains the PID of the most recently backgrounded command.
      local pid=$!
      echo $pid >> $_WARP_GENERATOR_PIDS_STARTED_TMP_FILE
      wait $pid 2> /dev/null

      # If the exit code of the backgrounded _warp_execute_command process is non-zero,
      # the call to send the generator output failed (most likely because this is being
      # executed in an old bash version that doesn't support some syntax in
      # _warp_execute_command function itself). In this case, send empty output with
      # exit code 1 to indicate generator execution failed.
      if [[ $? -ne 0 ]]; then
          warp_send_generator_output_osc "$1;;1"
      fi


      # Add the PID to the completed generators PID file.
      # 
      # The completed generator PIDs file may not exist if this generator was (by
      # error) left running/not cancelled properly in warp_preexec.
      if [[ -f $_WARP_GENERATOR_PIDS_COMPLETED_TMP_FILE ]]; then
        echo $pid >> $_WARP_GENERATOR_PIDS_COMPLETED_TMP_FILE
      fi
    }

    # Executes a generator command in the background, where the first argument is
    # the "command ID" assigned by the Rust app and the second-nth arguments
    # specify the command to be run.
    #
    # Note that the command string should be single-quoted so any variables are
    # not substituted until the command string is actually evaluated.
    #
    # Usage:
    #   warp_run_generator_command <command_id> '<command> <arg1> ... <argn>'
    warp_run_generator_command() {
      # Setting this environment variable prevents warp_precmd from emitting the
      # 'Block started' hook to the Rust app.
      _WARP_GENERATOR_COMMAND=1

      # Ensure the started and completed generator PID files exist.
      if [[ -z $_WARP_GENERATOR_PIDS_STARTED_TMP_FILE || ! -f $_WARP_GENERATOR_PIDS_STARTED_TMP_FILE ]]; then
        _WARP_GENERATOR_PIDS_STARTED_TMP_FILE="$(command -p mktemp)"
      fi
      if [[ -z $_WARP_GENERATOR_PIDS_COMPLETED_TMP_FILE || ! -f $_WARP_GENERATOR_PIDS_COMPLETED_TMP_FILE ]]; then
        _WARP_GENERATOR_PIDS_COMPLETED_TMP_FILE="$(command -p mktemp)"
      fi

      # To minimize latency and prevent the user from being blocked from entering a command,
      # cache the user's precmd_functions and only register warp_precmd. In the warp_precmd
      # execution following this generator command, the user's precmd_functions are restored.
      _USER_PRECMD_FUNCTIONS=(${precmd_functions[@]})
      precmd_functions=(warp_precmd)

      # $@ must be double-quoted to prevent word-splitting, which would cause the given command to
      # be split into a bash list on $IFS chars (spaces, tabs, newlines), which could invalidate
      # the syntactical correctness of the command.
      (_warp_run_generator_command_internal "$@" &)
    }


    # Note that this is very performance sensitive code, so try not to
    # invoke any external commands in here.
    warp_preexec () {
        # Use the $BASH_COMMAND environment variable instead of $1, which is passed in by bash_preeexec.
        #
        # Bash_preexec intends to pass the command to preexec functions (as $1), but it utilizes session
        # history to do so. This means that $1 is not the correct command if the executed command is ignored
        # by history (e.g. via $HISTCONTROL or $HISTIGNORE); for example, all in-band generators are ignored
        # by history.
        if [ "$WARP_IN_MSYS2" = true ]; then
          warp_send_hook_via_kv_pairs_start "Preexec"
          warp_send_hook_kv_pair "command" "$BASH_COMMAND"
          warp_send_hook_kv_pair "session_id" "$WARP_SESSION_ID"
          warp_send_hook_via_kv_pairs_end
        else
          local truncated_command=$(warp_escape_json "$BASH_COMMAND")
          warp_send_json_message "{\"hook\": \"Preexec\", \"value\": {\"command\": \"$truncated_command\", \"session_id\": $WARP_SESSION_ID}}"
        fi
        warp_maybe_send_reset_grid_osc


        # Since we did not early-return above, this hook is for a user-entered
        # command. Kill ongoing generator jobs so their output does not interfere
        # with the user command's output.
        if [[ "$BASH_COMMAND" != warp_run_generator_command* ]] && [[ -f $_WARP_GENERATOR_PIDS_STARTED_TMP_FILE ]] && [[ -f $_WARP_GENERATOR_PIDS_COMPLETED_TMP_FILE ]]
        then
          # Read PIDs from the started generators tmp file that are not present in
          # the completed generators tmp file into a bash array.
          #
          # The logic used to be the following:
          #
          # pids=($(command -p comm -23 $_WARP_GENERATOR_PIDS_STARTED_TMP_FILE $_WARP_GENERATOR_PIDS_COMPLETED_TMP_FILE))
          #
          # However, that requires that the files are sorted, which we do not enforce (the OS can assign PIDs
          # in any order).  While we could sort the files and then compare them, the files are expected to be
          # small, so we avoid the overhead of spawning multiple processes and instead do the comparison
          # manually.
          completed_pids=()
          while IFS= read -r pid; do
            completed_pids+=("$pid")
          done < $_WARP_GENERATOR_PIDS_COMPLETED_TMP_FILE

          pids=()
          while IFS= read -r pid; do
            found=0
            for completed_pid in "${completed_pids[@]}"; do
              if [[ "$pid" == "$completed_pid" ]]; then
                found=1
                break
              fi
            done
            if (( found == 0 )); then
              pids+=("$pid")
            fi
          done < $_WARP_GENERATOR_PIDS_STARTED_TMP_FILE

          # If the array is not empty, kill the ongoing pids.
          if [[ ! -z $pids ]]; then
            # Suppress stderr output; kill writes to stderr if any of the given
            # PIDS are not running (which might rarely be the case due to race
            # conditions in checking which PIDS to cancel and this kill command.
            kill -9 $pids >/dev/null 2>/dev/null
          fi 
        fi
    }

    # Set terminal window and tab title to the same title value. Note that for values longer than 25
    # characters, we truncate the title and prepend "..".
    # Usage warp_title "title"
    # Users can disable the auto title if they chose to by setting WARP_DISABLE_AUTO_TITLE.
    warp_title () {
      DISABLE_AUTO_TITLE="1"

      # truncating the title's len to 25 characters and leading ".."
      tmp_len=$((${#1}-25)) # starting character's position
      len=$((tmp_len>0 ? tmp_len : 0)) # account for the shorter strings
      if [[ $len -ne 0 ]]; then
        title="..${1:$len}" # shorten the argument and prepend the leading ".."
      else
        title="$1"
      fi
      # Set the title. Be sure to make the title a %s argument to prevent title content from ending up
      # in the block output, see:
      # https://linear.app/warpdotdev/issue/WAR-6064/bash-commands-having-esc-write-the-command-to-the-block-output
      printf "\033]0;%s\a" "$title"
    }

    # Runs before executing the command
    warp_set_title_idle_on_precmd () {
      # If the user wants to set the title themselves, they can set the WARP_DISABLE_AUTO_TITLE flag.
      if [ ! -z "$WARP_DISABLE_AUTO_TITLE" ]; then
        return
      fi

      # Note that in older versions of bash (the one builtin with MacOS) the `~` character is just that, 
      # however, when used within `""` (double quotes) on a newer (homebrew) bash version,
      # it automatically EXPANDS to the actual value of $HOME and needs to be escaped to give a proper
      # tilde character. So instead, we have it as a separate variable that uses `''` (single quote)
      # to avoid expanding, and use it later within the new bash term title. This way both old and
      # new bash see tilde as tilde, and tilde only.
      new_home='~'
      bash_term_tab_title="${PWD/#$HOME/$new_home}"

      if [[ $GALAXY_IS_LOCAL_SHELL_SESSION == "1" ]]; then
        warp_title "$bash_term_tab_title"
      else
        bash_term_tab_title_remote="${HOSTNAME%%.*}:$bash_term_tab_title"
        warp_title "$bash_term_tab_title_remote"
      fi
    }

    # Runs before executing the command
    warp_set_title_active_on_preexec () {
      # If the user wants to set the title themselves, they can set the WARP_DISABLE_AUTO_TITLE flag.
      if [ ! -z "$WARP_DISABLE_AUTO_TITLE" ]; then
        return
      fi

      cmd="$1"
      # warp_set_title_active_on_preexec is a preexec_function, which accepts 1 argument 
      #(currently invoked command)
      local this_command_spec
      read -r -a this_command_spec <<< "$1"

      # if running fg, figure out the command from its process id
      if [[ "${this_command_spec[0]}" == "fg" ]]; then 
        # note that `fg` and `jobs` essentially take the same arguments (but to be extra safe, 
        # we swapped empty/no-arguments to current background process), so we can just use that
        jobspec=${this_command_spec[1]}
        if [[ "$jobspec" == "" ]]; then
          jobspec="%%"
        fi
        # the output is of format:
        # [1]+  Stopped                 <Command>
        # the following modifications replace all whitespaces to a single space, and remote first
        # two columns from the output (leaving the command name, which itself can include spaces).
        fg_command_name=$(jobs "$jobspec" 2> /dev/null | command -p tr -s ' ' | command -p cut -d ' ' -f3-)
        if [[ "$fg_command_name" == "" ]]; then
          # in the weird case when this returns an empty string, lets just stick to whatever the
          # tab title was originally set to.
          return
        fi
        cmd="$fg_command_name"
      fi

      warp_title "$cmd"
    }

    # The git prompt's git commands are read-only and should not interfere with
    # other processes. This environment variable is equivalent to running with `git
    # --no-optional-locks`, but falls back gracefully for older versions of git.
    # See git(1) for and git-status(1) for a description of that flag.
    #
    # We wrap in a local function instead of exporting the variable directly in
    # order to avoid interfering with manually-run git commands by the user.
    warp_git () {
      GIT_OPTIONAL_LOCKS=0 command git "$@"
    }

    # Note that this is very performance sensitive code, so try not to
    # invoke any external commands in here.
    warp_precmd () {
        # $? is relative to the process so we MUST check this first
        # or else the exit code will correspond to the commands
        # executed within this block instead of the actual last
        # command that was run.
        local exit_code=$?
        local next_block_id="precmd-$WARP_SESSION_ID-$((block_id++))"
        if [ "$WARP_IN_MSYS2" = true ]; then
          warp_send_hook_via_kv_pairs_start "CommandFinished"
          warp_send_hook_kv_pair "exit_code" "$exit_code"
          warp_send_hook_kv_pair "next_block_id" "$next_block_id"
          warp_send_hook_kv_pair "session_id" "$WARP_SESSION_ID"
          warp_send_hook_via_kv_pairs_end
        else
          warp_send_json_message "{\"hook\": \"CommandFinished\", \"value\": {\"exit_code\": $exit_code, \"next_block_id\": \"$next_block_id\", \"session_id\": $WARP_SESSION_ID}}"
        fi

        warp_maybe_send_reset_grid_osc

        if [[ $PS1 == "" ]]; then
          # Use the saved PS1, if we've already unset it (due to active Warp prompt).
          WARP_PS1="$SAVED_PS1"
        else
          # If we haven't unset it yet, then we can use the current PS1 value.
          WARP_PS1="$PS1"
        fi

        # If this is being called for a generator command, short circuit and send an unpopulated
        # precmd payload (except for pwd), since we don't re-render the prompt after generator commands
        # are run.
        if [ ! -z  $_WARP_GENERATOR_COMMAND ]; then
            # Restore the user's precmd_functions, since they were un-registered prior to executing
            # the generator.
            precmd_functions=(${_USER_PRECMD_FUNCTIONS[@]})

            unset _WARP_GENERATOR_COMMAND
            warp_send_json_message "{\"hook\": \"Precmd\", \"value\": {
            \"exit_code\": $exit_code,
            \"next_block_id\": \"$next_block_id\",
            \"pwd\": \"\",
            \"ps1\": \"\",
            \"git_head\": \"\",
            \"git_branch\": \"\",
            \"virtual_env\": \"\",
            \"conda_env\": \"\",
            \"node_version\": \"\",
            \"session_id\": $WARP_SESSION_ID,
            \"is_after_in_band_command\": true
            }}"
            return 0
        fi

        # If the files for tracking generator PIDs exist, clear them.
        if [[ -n $_WARP_GENERATOR_PIDS_STARTED_TMP_FILE && -f $_WARP_GENERATOR_PIDS_STARTED_TMP_FILE ]]; then
          echo "" > $_WARP_GENERATOR_PIDS_STARTED_TMP_FILE
        fi
        if [[ -n $_WARP_GENERATOR_PIDS_COMPLETED_TMP_FILE && -f $_WARP_GENERATOR_PIDS_COMPLETED_TMP_FILE ]]; then
          echo "" > $_WARP_GENERATOR_PIDS_COMPLETED_TMP_FILE
        fi

        if [[ -z $WARP_INPUT_REPORTING_SUPPORTED ]]; then
          WARP_INPUT_REPORTING_SUPPORTED=$(warp_input_reporting_supported)
        fi

        # If we haven't already, cache information about supported features.
        if [[ -z $WARP_PS1_EXPANSION_SUPPORTED ]]; then
          WARP_PS1_EXPANSION_SUPPORTED=$(warp_ps1_expanding_supported)
        fi

        if [[ $WARP_PS1_EXPANSION_SUPPORTED  == "1" ]]; then
          # When evaluating the PS1, we want to ensure that it's aware of the last exit code.
          # Since we captured it already and executed multiple other commands, the actual
          # last exit code has changed. So before the evaluation, we want to trick the shell
          # into returning the correct value for the $? that may be in PS1
          exit_code_hack() {
            return $1
          }
          exit_code_hack $exit_code
          deref_ps1=${WARP_PS1@P}
        else
          # Tricking the shell into rendering the prompt
          # Note that in more modern versions of bash we could use ${PS1@P} to achieve the same,
          # but MacOS comes by default with a much older version of bash, and we want to be compatible.
          deref_ps1=$(echo -e "\n" | PS1="$WARP_PS1" BASH_SILENCE_DEPRECATION_WARNING=1 "$BASH" --norc -i 2>&1 | command -p head -2 | command -p tail -1)
        fi

        # Escaped PS1 variable
        local escaped_ps1
        if [ "$WARP_IN_MSYS2" = false ]; then
          escaped_ps1=$(warp_escape_ps1 "$(echo "$deref_ps1")")
        fi

        # Flush history
        history -a

        # Reset the custom kill-whole-line binding as the user's bashrc (which is sourced after bashrc_warp)
        # could have added another bind. This won't have any user-impact because these shortcuts are only run
        # in the context of the bash editor, which isn't displayed in Warp.
        bind -r '"\C-p"'
        bind "\C-p":kill-whole-line

        # Reset the report-input binding in case the user's bashrc modified it.
        # This is arbitrarily bound to ESC-i in all supported shells ("i" for input).
        if [[ $WARP_INPUT_REPORTING_SUPPORTED == "1" ]]; then
          bind -r '"\ei"'
          bind -x '"\ei":"warp_report_input"'
        fi
        
        # We need to register bindkeys to enable intra-session switching of the prompt 
        # (these bindkeys are used by Warp to communicate the prompt mode switch to bash).
        # We remove any existing bindkey for ESC-P ("p" for prompt/PS1) and register the bindkey
        # to our custom function. Note that this specific keybinding is arbitrary.
        bind -r '"\ep"'
        bind -x '"\ep":"warp_change_prompt_modes_to_ps1"'
        # We remove any existing bindkey for ESC-P ("w" for Warp prompt) and register the bindkey
        # to our custom function. Note that this specific keybinding is arbitrary.
        bind -r '"\ew"'
        bind -x '"\ew":"warp_change_prompt_modes_to_warp_prompt"'

        local escaped_pwd
        if [ "$WARP_IN_MSYS2" = false ]; then
          if [ -n "$WSL_DISTRO_NAME" ]; then
            # In WSL, avoid symlinks b/c on Windows `std::fs` is unable to resolve symlink inside WSL containers.
            escaped_pwd=$(warp_escape_json "$(pwd -P)")
          else
            escaped_pwd=$(warp_escape_json "$PWD")
          fi
        fi

        local escaped_virtual_env=""
        local escaped_conda_env=""
        local escaped_node_version=""
        local escaped_git_head=""
        local escaped_git_branch=""
        local git_head=""
        local git_branch=""

        # Only fill these fields once we've finished bootstrapping, as the
        # blocks created during the bootstrap process don't have visible
        # prompts, and we don't want to invoke `git` before we've sourced the
        # user's rcfiles and have a fully-populated PATH.
        if [[ -n "$WARP_BOOTSTRAPPED" ]]; then
          if [[ -n "$VIRTUAL_ENV" ]] && [ "$WARP_IN_MSYS2" = false ]; then
              escaped_virtual_env=$(warp_escape_json "$VIRTUAL_ENV")
          fi

          if [[ -n "$CONDA_DEFAULT_ENV" ]] && [ "$WARP_IN_MSYS2" = false ]; then
              escaped_conda_env=$(warp_escape_json "$CONDA_DEFAULT_ENV")
          fi

          # Get the Node.js version, but only when the Node.js Version chip is enabled.
          # Warp sets WARP_PROMPT_NODE_VERSION_ENABLED to "0" when the chip is not in the
          # prompt (defaulting to enabled when unset), so we avoid spawning `node` on
          # every prompt when the chip is not shown.
          if [[ "$WARP_PROMPT_NODE_VERSION_ENABLED" != "0" ]] && command -v node > /dev/null 2>&1 && [ "$WARP_IN_MSYS2" = false ]; then
              # Check for package.json in current directory and parent directories
              local current_dir="$PWD"
              local found_package_json=false
              local package_json_dir=""
              while [[ -n "$current_dir" ]]; do
                  if [[ -f "$current_dir/package.json" ]]; then
                      found_package_json=true
                      package_json_dir="$current_dir"
                      break
                  fi
                  [[ "$current_dir" == "/" ]] && break
                  # Strip the last path segment without spawning `dirname`.
                  current_dir="${current_dir%/*}"
                  [[ -z "$current_dir" ]] && current_dir="/"
              done
              
              # Only show node version if package.json is within a git repository
              if [[ "$found_package_json" = true ]]; then
                  local git_dir="$package_json_dir"
                  local in_git_repo=false
                  while [[ -n "$git_dir" ]]; do
                      if [[ -d "$git_dir/.git" ]]; then
                          in_git_repo=true
                          break
                      fi
                      [[ "$git_dir" == "/" ]] && break
                      git_dir="${git_dir%/*}"
                      [[ -z "$git_dir" ]] && git_dir="/"
                  done
                  
                  if [[ "$in_git_repo" = true ]]; then
                      # Cache the resolved version keyed on PWD + PATH so we only spawn
                      # `node --version` when the directory or PATH changes (PATH changes
                      # on `nvm use`). The cache vars are global (no `local`) so they
                      # persist across precmd invocations.
                      local node_cache_key="$PWD:$PATH"
                      if [[ "$node_cache_key" == "$_WARP_NODE_VERSION_CACHE_KEY" ]]; then
                          escaped_node_version="$_WARP_NODE_VERSION_CACHE_VALUE"
                      else
                          local node_version=$(node --version 2>/dev/null)
                          if [[ -n "$node_version" ]]; then
                              escaped_node_version=$(warp_escape_json "$node_version")
                          fi
                          _WARP_NODE_VERSION_CACHE_KEY="$node_cache_key"
                          _WARP_NODE_VERSION_CACHE_VALUE="$escaped_node_version"
                      fi
                  fi
              fi
          fi

          # Note: We explicitly do _not_ use command -p here, as `git` is a command that can be
          # installed in non-standard locations and so is not always available on the shell's
          # default PATH. Instead, we rely on the active PATH, as if the user doesn't have git
          # available to their session, it is unlikely they will be looking for git branch
          # information from the prompt.
          if command -v git >/dev/null 2>&1; then
            git_branch=$(warp_git symbolic-ref --short HEAD 2> /dev/null)
            # The git branch the user is on, or the git commit hash if they're not on a branch.
            git_head="${git_branch:-$(warp_git rev-parse --short HEAD 2> /dev/null)}"
          fi
          if [ "$WARP_IN_MSYS2" = false ]; then
            escaped_git_head=$(warp_escape_json "$git_head")
            escaped_git_branch=$(warp_escape_json "$git_branch")
          fi
        fi

        # At this point, escaped prompt looks something like
        # \\u{001B}\\u{005B}\\u{0030}\\u{0031}\\u{003B} ...

        # We need to maintain the double quoting of \\u in the message that
        # is sent otherwise the receiving side will interpret the value
        # as JS string literals of the form \uHEX, and will include
        # ctrl characters (like ESC) in the json, which will cause a JSON
        # parse error.
        # Note WARP_SESSION_ID doesn't need to be escaped since it's a number
        # We also pass the shell's notion of `honor_ps1` to ensure it's synced correctly on the Warp-side for prompt handling.
        # This is passed as a "real boolean" via the JSON payload (string interpolated into JSON string below).
        local honor_ps1
        if [[ "$WARP_HONOR_PS1" == "1" ]]; then
          honor_ps1="true"
          # The Warp prompt preview can be rendered using the active prompt in this case (which uses prompt markers).
          escaped_ps1=""
          deref_ps1=""
        else
          honor_ps1="false"
        fi
        # We send the escaped PS1, if we are in active Warp prompt mode, for prompt preview rendering (note the shell's PS1 is unset in this case).
        if [ "$WARP_IN_MSYS2" = true ]; then
          warp_send_hook_via_kv_pairs_start "Precmd"
          warp_send_hook_kv_pair "exit_code" "$exit_code"
          warp_send_hook_kv_pair "next_block_id" "$next_block_id"
          warp_send_hook_kv_pair "pwd" "$PWD"
          warp_send_hook_kv_pair_escaped "ps1" "$deref_ps1"
          warp_send_hook_kv_pair "ps1_is_encoded" "false"
          warp_send_hook_kv_pair "honor_ps1" "$honor_ps1"
          warp_send_hook_kv_pair "git_head" "$git_head"
          warp_send_hook_kv_pair "git_branch" "$git_branch"
          warp_send_hook_kv_pair "virtual_env" "$VIRTUAL_ENV"
          warp_send_hook_kv_pair "conda_env" "$CONDA_DEFAULT_ENV"
          warp_send_hook_kv_pair "node_version" "$node_version"
          warp_send_hook_kv_pair "session_id" "$WARP_SESSION_ID"
          warp_send_hook_via_kv_pairs_end
        else
          local escaped_json="{\"hook\": \"Precmd\", \"value\": {
          \"exit_code\": $exit_code,
          \"next_block_id\": \"$next_block_id\",
          \"pwd\": \"$escaped_pwd\",
          \"ps1\": \"$escaped_ps1\",
          \"honor_ps1\": $honor_ps1,
          \"ps1_is_encoded\": true,
          \"git_head\": \"$escaped_git_head\",
          \"git_branch\": \"$escaped_git_branch\",
          \"virtual_env\": \"$escaped_virtual_env\",
          \"conda_env\": \"$escaped_conda_env\",
          \"node_version\": \"$escaped_node_version\",
          \"session_id\": $WARP_SESSION_ID
          }}"
          warp_send_json_message "$escaped_json"
        fi
    }

    warp_clear_on_next_block () {
        warp_send_json_message '{"hook": "ClearOnNextBlock"}'
    }

    # Format a string value according to JSON syntax.
    warp_escape_json () {
        # Explanation of the sed replacements (each command is separated by a `;`):
        # s/(["\\])/\\\1/g - Replace all double-quote (") and backslash (\) characters with the escaped versions (\" and \\)
        # s/\b/\\b/g - Replace all backspace characters with \b
        # s/\t/\\t/g - Replace all tab characters with \t
        # s/\f/\\f/g - Replace all form feed characters with \f
        # s/\r/\\r/g - Replace all carriage return characters with \r
        # $!s/$/\\n/ - On every line except the last, insert the \n escape at the end of the line
        #              Note: sed acts line-by-line, so it doesn't see the literal newline characters to replace
        #
        # tr -d '\n' - Remove the literal newlines from the final output
        #
        # Additional note: In a shell script between single quotes ('), no escape sequences are interpreted.
        # To work around that and insert the literal values into the regular expressions, we stop the single-quote,
        # then add the literal using ANSI-C syntax ($'\t'), then start a new single-quote. That is the meaning
        # behind the various `'$'\b''` blocks in the command. All of these separate strings are then concatenated
        # together to form the full argument to send to sed.
        #
        # We also use 'command sed' to ensure that we aren't accidentally executing an alias or function named 'sed'
        command -p sed -E 's/(["\\])/\\\1/g; s/'$'\b''/\\b/g; s/'$'\t''/\\t/g; s/'$'\f''/\\f/g; s/'$'\r''/\\r/g; $!s/$/\\n/' <<<"$*" | command -p tr -d '\n'
    }

    # Turns out that the processed prompt is a complicated data structure that includes lots of 
    # information that's passed to the shell (including the actual shell, version, working directory
    # and, well, the prompt itself). What is more, prompt can also include emojis - unicode characters
    # that sometimes contain special bytes (ie. ST, CAN or SUB) that are otherwise used as unhook
    # triggers for the precmd. Instead of escaping those and extracting the value of the prompt itself,
    # we simply convert the entire data structure into a single line hex string, which Warp
    # later decodes and sends to the grid to show the prompt.
    # Note: before converting the prompt to a hex string, we remove the multi-line newlines and replace
    # them with a single space (to avoid prompts that span multiple empty lines).
    warp_escape_ps1 () {
       command -p tr '\n\n' ' ' <<< "$*" | command -p od -An -v -tx1 | command -p tr -d ' \n'
    }

    # warp_hex_encode_string encodes the entire DCS string (JSON) with od making it essentially
    # a very long hexadecimal string.
    # Afterwards it's decoded in rust and parsed as usual.
    # Accepts one argument: DCS JSON string
    warp_hex_encode_string () {
      echo "$1" | command -p od -An -v -tx1 | command -p tr -d ' \n'
    }

    # Returns encoded InitShell hook
    # Accepts one argument: shell [bash, zsh, fish (future)]
    init_shell_hook () {
      init_shell="{\"hook\": \"InitShell\", \"value\": {\"shell\": \"$1\"}}"
      echo $(warp_hex_encode_string "$init_shell")
    }

    # Checks whether the current version of bash is at least as high as the expected ($1) one.
    # To match rest of our codebase, it returns "1" if the bash version is higher or equal, and 
    # 0 otherwise.
    warp_at_least_bash_version () {
      if [[ $(printf '%s\n%s\n' "$BASH_VERSION" "$1" | command -p sort -rVC ; echo $?) -eq 0 ]]; then
        echo "1"
      else 
        echo "0"
      fi
    }

    # @P substitution was introduced in 4.4 bash version, so it returns "1" if the current bash
    # version is 4.4 or higher.
    warp_ps1_expanding_supported () {
      warp_at_least_bash_version "4.4"
    }

    # The $READLINE_LINE variable in `bind -x` sequences was introduced in bash 4.0,
    # so we can only report the input buffer if the bash version is 4.0 or higher.
    warp_input_reporting_supported () {
        warp_at_least_bash_version "4.0"
    }

    # Report the current input buffer contents to Warp. This only works correctly
    # if `warp_input_reporting_supported` returns "1".
    warp_report_input () {
        if [ "$WARP_IN_MSYS2" = true ]; then
            warp_send_hook_via_kv_pairs_start "InputBuffer"
            warp_send_hook_kv_pair "buffer" "$READLINE_LINE"
            warp_send_hook_kv_pair "session_id" "$WARP_SESSION_ID"
            warp_send_hook_via_kv_pairs_end
        else
            local escaped_input="$(warp_escape_json "$READLINE_LINE")"
            warp_send_json_message "{ \"hook\": \"InputBuffer\", \"value\": { \"buffer\": \"$escaped_input\", \"session_id\": $WARP_SESSION_ID } }"
        fi
        # This prevents bash from re-printing typeahead after we've removed it.
        READLINE_LINE=""
    }

    # Check whether the prompt-related variables have OSC prompt marker sequences,
    # and if not, wrap them with the appropriate markers so that we can direct the
    # prompt bytes to the appropriate grids.
    function warp_update_prompt_vars() {
      # 133;A and 133;B are standard prompt marker OSCs.
      # See https://learn.microsoft.com/en-us/windows/terminal/tutorials/shell-integration and
      # https://gitlab.freedesktop.org/terminal-wg/specifications/-/merge_requests/6/diffs for details.
      local prompt_prefix=$'\e]133;A\a'
      local prompt_suffix=$'\e]133;B\a'
      if [[ "$WARP_HONOR_PS1" != "1" ]] && [ "$WARP_USING_WINDOWS_CON_PTY" = true ]; then
        local suffix="$prompt_suffix$RESET_GRID_OSC"
      else
        local suffix="$prompt_suffix"
      fi

      # The "\[" and "\]" indicate to bash that the sequence between the markers are 
      # "non-printable", which effectively means they should not change the position
      # of the cursor as they're "printed".
      local prompt_prefix_with_cursor_marker_surrounded="\[$prompt_prefix\]"
      local suffix_with_cursor_marker_surrounded="\[$suffix\]"

      # Clear the user-defined prompt again, if using Warp's built-in prompt, before the command 
      # is rendered as it could have been reset by the user's bashrc or by setting 
      # the variable on the command line. This is used for same-line prompt and leads to the temporary
      # product behavior of Warp prompt switches only taking effect in new sessions.
      # Certain prompt plugins can reset the prompt to a non-empty value, after we've initially unset it.
      # Confirm that it is unset, if using built-in Warp prompt (update prompt vars is forced to run as the last precmd fn).
      if [[ "$WARP_HONOR_PS1" != "1" ]]; then
        if [[ "$PS1" != "" ]]; then
          # If the PS1 has its original value, then we save it in SAVED_PS1 so we can restore to this value, if we were to unset it for
          # the Warp prompt case, but the user wants to switch back to PS1 later.
          SAVED_PS1=$PS1
        fi
        # Note that we DO NOT unset the PS1 here, since we want to pass it along as a "hidden left prompt" for 
        # prompt preview purposes, if the Warp prompt is being used. Specifically, we want to show this prompt preview
        # for the Edit Prompt modal and onboarding prompt block.
      fi

      if [[ -n "$PS1" ]]; then
        # Remove any existing prompt/cursor markers from the prompt, before we re-modify it. Notably,
        # we want to wrap the latest version of the prompt (which may have been changed e.g. virtualenv
        # added).
        if [[ "$PS1" == *"$prompt_prefix_with_cursor_marker_surrounded"* ]]; then
          local preceding_prefix=${PS1%%"$prompt_prefix_with_cursor_marker_surrounded"*}
          local following_prefix=${PS1#*"$prompt_prefix_with_cursor_marker_surrounded"}
          PS1=$preceding_prefix$following_prefix
        fi
        if [[ "$PS1" == *"$suffix_with_cursor_marker_surrounded"* ]]; then
          local preceding_suffix=${PS1%"$suffix_with_cursor_marker_surrounded"*}
          local following_suffix=${PS1##*"$suffix_with_cursor_marker_surrounded"}
          PS1=$preceding_suffix$following_suffix
        fi

        ORIGINAL_PS1=$PS1
        PS1="$prompt_prefix$PS1$suffix"
      fi

      # Unset the PS1, if we are using the Warp prompt.
      if [[ "$WARP_HONOR_PS1" != "1" ]]; then
        PS1=""
      # Otherwise, if we are using the PS1, we use the normal prompt markers.
      else
        if [[ "$PS1" != "\["*"\]" ]]; then
          # We surround the non-printable OSCs with cursor markers to make sure the shell does NOT
          # account for them when keeping track of its internal cursor position.
          PS1="\[$prompt_prefix\]$ORIGINAL_PS1\[$suffix\]"
        fi
      fi

      # Ensure that this is always the last precmd hook. This prevents any other precmd hook, which might
      # modify $PS1, from interfering with our prompt-escaping logic.
      #
      # Remove warp_update_prompt_vars from the precmd_functions list and then re-append it to ensure it's
      # ordered last.

      # Initialize an empty array to hold the filtered functions.
      filtered_precmd_functions=()

      # Loop through each function in the original precmd_functions array.
      for func in "${precmd_functions[@]}"; do
        # Add the function to the filtered array if it's not warp_update_prompt_vars
        if [[ "$func" != "warp_update_prompt_vars" ]]; then
          filtered_precmd_functions+=("$func")
        fi
      done

      # Assign the filtered array back to precmd_functions.
      precmd_functions=("${filtered_precmd_functions[@]}")

      # Append warp_update_prompt_vars to the end of the precmd_functions array.
      precmd_functions+=("warp_update_prompt_vars")
    }
    
    # Changes the WARP_HONOR_PS1 variable to 1, to indicate we want to use the PS1. Restores
    # the original PS1 value (which we unset for Warp prompt) and calls warp_update_prompt_vars
    # to refresh the prompt. Note that we use an "empty block" workaround to achieve instant
    # prompt switching in bash, since there is no built-in methods to repaint the prompt, unlike
    # Zsh/fish.
    function warp_change_prompt_modes_to_ps1() {
      PS1="$SAVED_PS1"
      WARP_HONOR_PS1="1"

      warp_update_prompt_vars
    }

    # Changes the WARP_HONOR_PS1 variable to 0, to indicate we want to use the Warp prompt. Calls 
    # warp_update_prompt_vars to refresh the prompt (note the PS1 will be unset in this logic). 
    # Note that we use an "empty block" workaround to achieve instant prompt switching in bash, 
    # since there is no built-in methods to repaint the prompt, unlike Zsh/fish.
    function warp_change_prompt_modes_to_warp_prompt() {
      WARP_HONOR_PS1="0"

      warp_update_prompt_vars
    }

    function clear() {
        if [ "$WARP_IN_MSYS2" = true ]; then
            warp_send_hook_via_kv_pairs_start "Clear"
            warp_send_hook_kv_pair "session_id" "$WARP_SESSION_ID"
            warp_send_hook_via_kv_pairs_end
        else
            warp_send_json_message "{\"hook\": \"Clear\", \"value\": {\"session_id\": $WARP_SESSION_ID}}"
        fi
    }

    function warp_finish_update {
      local update_id="$1"
      if [ "$WARP_IN_MSYS2" = true ]; then
        warp_send_hook_via_kv_pairs_start "FinishUpdate"
        warp_send_hook_kv_pair "update_id" "$update_id"
        warp_send_hook_kv_pair "session_id" "$WARP_SESSION_ID"
        warp_send_hook_via_kv_pairs_end
      else
        warp_send_json_message "{ \"hook\": \"FinishUpdate\", \"value\": { \"update_id\": \"$update_id\", \"session_id\": $WARP_SESSION_ID} }"
      fi
    }

    # Check if the warp apt source file has been renamed to `warpdotdev.list.distUpgrade` due to an ubuntu version update.
    # If this occurred, we want to rename the source file back to `warpdotdev.list` to ensure updates can proceed.
    # We purposefully skip this if either the `warpdotdev.list` file already exists (indicating that the user has already
    # done this themselves) _or_ if a `warpdotdev.sources` file exists (which is the new Deb822 format for source files).
    # The `.sources` file could only exist if a user manually created it; Ubuntu doesn't create one automatically for the
    # warp source file due to a bug in its update flow where it considers our source file to be "invalid" because it
    # contains a `signed-by` key.
    function warp_handle_dist_upgrade {
      local source_file_name="$1"

      eval "$(command apt-config shell APT_SOURCESDIR 'Dir::Etc::sourceparts/d')"

      if [[ ! -e $APT_SOURCESDIR$source_file_name.list && \
          ! -e $APT_SOURCESDIR$source_file_name.sources && \
           -e $APT_SOURCESDIR$source_file_name.list.distUpgrade ]]; then
        # DO NOT DO THIS. We should never run a command for user with `sudo`. The only reason this is safe here is because
        # we insert this function into the input for the user to determine if they want to execute (we never run it on
        # their behalf without their permission).  To be transparent about what is being executed with sudo, we echo out the
        # command we're about to run.
        echo "Executing: sudo cp \"$APT_SOURCESDIR$source_file_name.list.distUpgrade\" \"$APT_SOURCESDIR$source_file_name.list\""
        sudo cp "$APT_SOURCESDIR$source_file_name.list.distUpgrade" "$APT_SOURCESDIR$source_file_name.list"
      fi
    }

    # The SSH logic only applies to local sessions, because we don't yet have support for bootstrapping
    # recursive SSH sessions.
    if [[ $GALAXY_IS_LOCAL_SHELL_SESSION == "1" ]]; then
        # This helper function determines whether the user's ssh arguments imply
        # creation of a non-interactive session or otherwise would conflict with
        # our SSH wrapper.  Returns 0 for an interactive session; >0 otherwise.
        function is_interactive_ssh_session() {
            ARGS=()    # this array holds any positional arguments
            while [ $# -gt 0 ]; do
                # Initialize this to 1 before each call, as per getopts documentation.
                OPTIND=1
                # Parse through all ssh options, as defined in the ssh man pages.
                while getopts :1246AaCfgKkMNnqsTtVvXxYyb:c:D:e:F:i:L:l:m:O:o:p:R:S:W:w: OPTION; do
                    case $OPTION in
                        # -T disables pty allocation (aka a non-interactive session)
                        T) return 1;;
                        # -W implies -T
                        W) return 1;;
                        # The user provided an invalid option; kick it to real ssh.
                        \?) return 1;;
                        # The user omitted a required argument; kick it to real ssh.
                        :) return 1;;
                    esac
                done
                [ $? -eq 0 ] || return 2       # getopts failed
                [ $OPTIND -gt $# ] && break    # we reached the end of the parameters

                shift "$((OPTIND - 1))"  # skip all options processed so far
                ARGS[${#ARGS[@]}]=$1     # save first non-option argument (a.k.a. positional argument)
                shift                    # remove saved arg
            done

            # If there is more than one positional argument, the user is attempting to
            # run a command, not start an interactive session.  If there is less than
            # one positional argument, the user should be shown the usage text.
            if [[ ${#ARGS[@]} -ne 1 ]]; then
                return 1
            fi
        }

        function warp_ssh_helper() {
            init_shell_bash=$(init_shell_hook "bash")
            init_shell_zsh=$(init_shell_hook "zsh")
            local remote_session_id=$(command -p od -An -N8 -tu8 /dev/urandom 2>/dev/null | command -p tr -d ' \n')
            if [[ -z "$remote_session_id" || "$remote_session_id" == "0" ]]; then
                # If we cannot generate a non-zero random token, run plain SSH instead.
                command ssh "${@:1}"
                return
            fi

            # Hex-encode the ZSH environment script we use to bootstrap remote zsh b/c it contains control characters
            # We decode on the SSH server using xxd if its available, otherwise fall back to a for-loop over each byte
            # and use printf to convert back to plaintext
            local zsh_env_script=$(printf '%s' 'unsetopt ZLE; unset RCS; unset GLOBAL_RCS; WARP_SESSION_ID='$remote_session_id'; WARP_USING_WINDOWS_CON_PTY=@@USING_CON_PTY_BOOLEAN@@; WARP_HONOR_PS1='$WARP_HONOR_PS1'; _hostname=$(command -pv hostname >/dev/null 2>&1 && command -p hostname 2>/dev/null || command -p uname -n); _user=$(command -pv whoami >/dev/null 2>&1 && command -p whoami 2>/dev/null || echo $USER); _msg=$(printf "{\"hook\": \"InitShell\", \"value\": {\"session_id\": $WARP_SESSION_ID, \"shell\": \"zsh\", \"user\": \"%s\", \"hostname\": \"%s\"}}" "$_user" "$_hostname" | command -p od -An -v -tx1 | command -p tr -d '"'"' \n'"'"'); printf '"'"'\e]9278;d;%s\x07'"'"' $_msg; unset _hostname _user _msg' | command -p od -An -v -tx1 | command -p tr -d ' \n')

            # Optionally attach to an existing ControlMaster the user already
            # runs for this destination instead of creating our own. Resolve
            # the user's configured ControlPath with `ssh -G` (which expands
            # tokens like %h/%p/%r/%C into a literal path), then verify the
            # master is alive with `ssh -O check`. Both probes are local-only
            # commands. On any failure we fall back to creating a Warp-owned
            # master, preserving the existing behavior.
            local control_path="$SSH_SOCKET_DIR/$WARP_SESSION_ID"
            local control_master_mode="yes"
            local external_control_master="false"
            if [[ "$GALAXY_SSH_REUSE_CONTROL_MASTER" == "1" ]]; then
                local user_control_path=$(command ssh -G "${@:1}" 2>/dev/null | command -p sed -n 's/^controlpath //p')
                case "$user_control_path" in
                    "" | none)
                        # No ControlPath configured for this destination.
                        ;;
                    *[![:alnum:]._/~@:+,-]*)
                        # The resolved path contains characters we cannot safely
                        # embed in the SSH hook JSON below (e.g. an unexpanded %
                        # token, quotes, or whitespace); fall back to a
                        # Warp-owned master.
                        ;;
                    *)
                        if command ssh -O check -o ControlPath="$user_control_path" "${@:1}" >/dev/null 2>&1; then
                            # A live master exists: multiplex through it and let
                            # the client know Warp does not own it.
                            control_path="$user_control_path"
                            control_master_mode="no"
                            external_control_master="true"
                        fi
                        ;;
                esac
            fi

            # Keep remote commands up-to-date with shell.rs & bash.sh.
            # Note that in this command, we're passing a string to the remote shell. Any variable expansions need to be
            # escaped with "''" to avoid the local shell from expanding them before they're passed to the remote shell.
            # We check the SHELL env var and use shell string manipulation to get the contents after the last slash to
            # determine what shell is the login shell on the remote machine.  We perform a preliminary check to see if
            # the remote shell is the Bourne shell to avoid asking it to parse later lines that use syntax it doesn't
            # support.
            command ssh -o ControlMaster=$control_master_mode -o ControlPath="$control_path" \
            -t "${@:1}" \
"
export TERM_PROGRAM='WarpTerminal'
# Mark the remote side of a Warp-managed SSH session so the bootstrap
# body can distinguish it from local shells. Used to gate the ExitShell
# hook which tears down the remote-server-proxy subprocess.
export WARP_IS_SSH='1'
test -n '$GALAXY_CLIENT_VERSION' && export GALAXY_CLIENT_VERSION='$GALAXY_CLIENT_VERSION'
# Only forward the protocol version if it was set locally (i.e. the HOANotifications feature flag is on).
test -n '$GALAXY_CLI_AGENT_PROTOCOL_VERSION' && export GALAXY_CLI_AGENT_PROTOCOL_VERSION='$GALAXY_CLI_AGENT_PROTOCOL_VERSION'

hook="'$(printf "{\"hook\": \"SSH\", \"value\": {\"socket_path\": \"'$control_path'\", \"remote_shell\": \"%s\", \"session_id\": '"$WARP_SESSION_ID"', \"remote_session_id\": '"$remote_session_id"', \"external_control_master\": '"$external_control_master"'}}" "${SHELL##*/}" | command -p od -An -v -tx1 | command -p tr -d " \n")'"
printf '$OSC_START$DCS_JSON_MARKER$OSC_PARAM_SEPARATOR%s$OSC_END' "'$hook'"

if test "'"${SHELL##*/}" != "bash" -a "${SHELL##*/}" != "zsh"'"; then
  # Emulate the SSHD logic to print the MotD. Because the Warp SSH wrapper passes
  # a command to run, SSHD does a quiet login, updating utmp and other login
  # state, but not printing the MotD. For bash and zsh, this is instead handled
  # by our bootstrap script.
  if test ! -e "'$HOME/.hushlogin'"; then
    # This uses an if-else chain instead of a for-loop to avoid expansion issues on older shells.
    if test -r /etc/motd; then
      command -p cat /etc/motd
    elif test -r /run/motd; then
      command -p cat /run/motd
    elif test -r /run/motd.dynamic; then
      command -p cat /run/motd.dynamic
    elif test -r /usr/lib/motd; then
      command -p cat /usr/lib/motd
    elif test -r /usr/lib/motd.dynamic; then
      command -p cat /usr/lib/motd.dynamic
    fi
  fi
  # Likewise, emulate a login shell by sourcing /etc/profile
  if test -r /etc/profile; then
    . /etc/profile
  fi
  exec "'$SHELL'"
fi

case "'${SHELL##*/}'" in
  bash)
    exec -a bash bash --rcfile <(echo '"'
      command -p stty raw
      HISTCONTROL=ignorespace
      HISTIGNORE=" *"
      WARP_SESSION_ID='$remote_session_id'
      WARP_HONOR_PS1="'$WARP_HONOR_PS1'"
      _hostname=$(command -pv hostname >/dev/null 2>&1 && command -p hostname 2>/dev/null || command -p uname -n)
      _user=$(command -v whoami >/dev/null 2>&1 && command whoami 2>/dev/null || echo $USER)
      _msg=$(printf "{\"hook\": \"InitShell\", \"value\": {\"session_id\": $WARP_SESSION_ID, \"shell\": \"bash\", \"user\": \"%s\", \"hostname\": \"%s\"}}" "$_user" "$_hostname" | command -p od -An -v -tx1 | command -p tr -d " \n")'"
      WARP_USING_WINDOWS_CON_PTY=@@USING_CON_PTY_BOOLEAN@@
      if [[ "'$OS'" == Windows_NT ]]; then WARP_IN_MSYS2=true; else WARP_IN_MSYS2=false; fi
      printf '\''"'\e]9278;d;%s\x07'"'\'' \""'$_msg'"\"')
      unset _hostname _user _msg
      ;;
  zsh) WARP_TMP_DIR="'$(command -p mktemp -d warptmp.XXXXXX)'"
local ZSH_ENV_SCRIPT='$zsh_env_script'
if [[ "'$?'" == 0 ]]; then
  if command -pv xxd >/dev/null 2>&1; then
    echo "'$ZSH_ENV_SCRIPT'" | command -p xxd -p -r > "'$WARP_TMP_DIR'"/.zshenv
  else
    for i in {0..\$((\${#ZSH_ENV_SCRIPT} - 1))..2}; do
      builtin printf "'"\x${ZSH_ENV_SCRIPT:$i:2}"'"
    done > "'$WARP_TMP_DIR'"/.zshenv
  fi
else
  echo \"Failed to bootstrap warp. Continuing with a non-bootstrapped shell.\"
fi
TMPPREFIX="'$HOME/.zshtmp-'" WARP_SSH_RCFILES="'${ZDOTDIR:-$HOME}'" ZDOTDIR="'$WARP_TMP_DIR'" exec -l zsh -g $TRACE_FLAG_IF_WARP_SHELL_DEBUG_MODE
      ;;
esac
"
        }

        function ssh() {
            if is_interactive_ssh_session "$@"; then
                warp_send_json_message "{\"hook\": \"PreInteractiveSSHSession\", \"value\": {\"session_id\": $WARP_SESSION_ID}}"

                # If the SSH wrapper is not enabled for this session, don't use it.
                if [ "$GALAXY_USE_SSH_WRAPPER" = "1" ]; then
                    local TRACE_FLAG_IF_WARP_SHELL_DEBUG_MODE=""
                    if [[ "$WARP_SHELL_DEBUG_MODE" == "1" ]]; then
                        TRACE_FLAG_IF_WARP_SHELL_DEBUG_MODE="-x"
                    fi
                    warp_ssh_helper "$@"
                else
                    command ssh "$@"
                fi
            else
                command ssh "$@"
            fi
        }
    fi


    # Send a precmd message to the terminal to differentiate between the warp
    # bootstrap logic pasted into the PTY and the output of shell startup files.
    warp_precmd

    # Before calling rcfiles, print the MotD.
    # In general, login(1) or pam_motd(8) is supposed to do this. However, we don't
    # go through the normal login flow when bootstrapping a Warp session. In
    # addition, Warp bash shells are _not_ login shells, because bash does not
    # support custom rcfiles in login shells.
    if [[ ! -e "$HOME/.hushlogin" ]]; then
      for motd_file in /etc/motd /run/motd /run/motd.dynamic /usr/lib/motd /usr/lib/motd.dynamic; do
        if [[ -r "$motd_file" ]]; then
          command -p cat "$motd_file"
          break
        fi
      done
    fi


    # This reflects the bootstrap sequence in a login shell. We want to
    # Do other shell startup first so we can ensure Warp goes last.
    #
    # If this is a subshell, the user and system RC files have already been sourced.
    if [[ -z $WARP_IS_SUBSHELL ]]; then
        # Make sure we force the locale used for number formatting to "C", to avoid
        # issues in locales that use a comma as the decimal separator.
        rcfiles_start_time="$(LC_ALL="C"; echo $EPOCHREALTIME)"

        if [[ -e /etc/profile ]]; then
            source /etc/profile;
        elif [[ -e /etc/bash.bashrc ]]; then
            # /etc/bash.bashrc is only included in the startup sequence if bash is
            # compiled with -DSYS_BASHRC. This is disabled in bash by default but
            # included in Debian and adopted in other distributions. There's no efficient way
            # to tell if it's enabled or not, so just check for the file if there is
            # no /etc/profile and source it if it exists.
            # Note that a lot of the time, /etc/profile sources /etc/bash.bashrc.
            source /etc/bash.bashrc
        fi

        if [[ -e $HOME/.bash_profile ]]; then
            source $HOME/.bash_profile
        elif [[ -e $HOME/.bash_login ]]; then
            source $HOME/.bash_login
        elif [[ -e $HOME/.profile ]]; then
            source $HOME/.profile
        fi

        rcfiles_end_time="$(LC_ALL="C"; echo $EPOCHREALTIME)"
    fi

    # Unset HISTFILESIZE and HISTSIZE if the user rcfiles didn't change them
    # away from our very large sentinel values.  We need to set the initial
    # values to ensure that the user's history file and in-memory history list
    # don't get truncated when we spawn the shell, but once bootstrap has
    # completed, we want the values to be what they would have been if we hadn't
    # set initial values.
    #
    # For more context, see: https://github.com/warpdotdev/Warp/issues/1262
    if [[ $HISTFILESIZE == $WARP_INITIAL_HISTFILESIZE ]]; then
        unset HISTFILESIZE
    fi
    unset WARP_INITIAL_HISTFILESIZE
    if [[ $HISTSIZE == $WARP_INITIAL_HISTSIZE ]]; then
        unset HISTSIZE
    fi
    unset WARP_INITIAL_HISTSIZE

    # Save the value of HISTCONTROL as it existed just after reading the user's
    # rcfiles.
    USER_HISTCONTROL="$HISTCONTROL"

    # Add a pattern to ignore in-band commands in shell history, while preserving the user's
    # HISTIGNORE value which may been set in an RC file sourced above. It is important to
    # ensure that this happens _after_ the user's RC files have been sourced.
    if [[ ! -z $HISTIGNORE ]]; then
        HISTIGNORE="*warp_run_generator_command*:$HISTIGNORE"
    else
        HISTIGNORE="*warp_run_generator_command*"
    fi

    # If the user has PROMPT_COMMAND set in their bootstrap scripts,
    # save it into USER_PROMPT_COMMAND and install a precmd hook so we can
    # respect it. It behaves exactly the same as precmd (i.e. executed
    # before the prompt is shown).
    # Since bash-preexec actually uses PROMPT_COMMAND, we shouldn't do this if bash-preexec
    # is installed from /etc/bash.bashrc. If it's included in the user's rcfiles, it
    # should've guarded on the presence of bash_preexec_imported and no-oped.
    if [[ -n $PROMPT_COMMAND && -z $BASH_PREEXEC_IN_ETC_BASHRC ]]; then
        # Do not honor the user's PROMPT_COMMAND if it re-assigns PROMPT_COMMAND, as that
        # will break the precmd hook. This is the case in Kali Linux's default .bashrc
        # https://gist.github.com/Searge/158f9061da831a53eeacff44eac71447#file-bashrc-L100
        if [[ ! $PROMPT_COMMAND =~ "PROMPT_COMMAND=" ]]; then
            # We treat the PROMPT_COMMAND as an array in case users are using bash 5.1
            # array variant of PROMPT_COMMAND. If PROMPT_COMMAND is a string, this will
            # still work, just create a length 1 array.
            USER_PROMPT_COMMAND=("${PROMPT_COMMAND[@]}")
            function user_prompt_command() {
                for command in "${USER_PROMPT_COMMAND[@]}"; do
                    eval $command
                done
            }
        fi
        # We need to unset PROMPT_COMMAND here. Otherwise, it will be executed twice.
        unset PROMPT_COMMAND
    fi

    # If the user's rc files turned PROMPT_COMMAND into an array, we must undo that.
    # Since Bash 5.1, the PROMPT_COMMAND variable can be an array, see:
    #   https://tiswww.case.edu/php/chet/bash/NEWS
    # Unfortunately, doing so will break Warp because of the way it interacts with bash-preexec.
    # When PROMPT_COMMAND is an array, the DEBUG signal fires for each array element, and since
    # bash-preexec uses a DEBUG trap to trigger the preexec functions, it will run our preexec
    # functions before the command at PROMPT_COMMAND[1], PROMPT_COMMAND[2], etc. This means our
    # Preexec hook gets called without the user submitting a command, putting the input block into
    # a broken state, e.g. see https://github.com/warpdotdev/Warp/issues/2636
    # If they end up fixing this, we may be able to remove this at some point, check this:
    #   https://github.com/rcaloras/bash-preexec/issues/130
    #
    # If PROMPT_COMMAND is set and it's an array, "join" the array into a newline-delimited string,
    # then overwrite PROMPT_COMMAND
    if [[ -n $PROMPT_COMMAND && "$(declare -p PROMPT_COMMAND)" =~ "declare -a" ]]; then
        PROMPT_COMMAND_FLATTENED=$(IFS=$'\n'; echo "${PROMPT_COMMAND[*]}")
        unset PROMPT_COMMAND
        PROMPT_COMMAND=$PROMPT_COMMAND_FLATTENED
    fi

## ----- Bash_preexec initialization -----
    # If bash-preexec is already installed, we don't install it again.
    if [[ "${PROMPT_COMMAND:-}" != *"__bp_precmd_invoke_cmd"* ]]; then
        install_bashpreexec
    else
        # If we changed the HISTCONTROL value to work around the behavior in Debian bash,
        # we want to re-run the logic so bash-preexec works properly (otherwise, it won't
        # receive the command in preexec).
        __bp_adjust_histcontrol
    fi
## ----- Warp initialization -----
    
    # Append additional PATH entries if provided via WARP_PATH_APPEND. This is after the user's RC
    # files are sourced in case they reset PATH (/etc/profile on Debian does this, for example).
    if [[ ! -z "$WARP_PATH_APPEND" ]]; then
        export PATH="$PATH:$WARP_PATH_APPEND"
        unset WARP_PATH_APPEND
    fi

    # Read through shell options to determine if the user has enabled vi mode.
    vi_mode_enabled=0
    IFS=':' read -ra SHELLOPT <<< "$SHELLOPTS"
    for i in "${SHELLOPT[@]}"; do
        if [[ "$i" == "vi" ]]; then
            vi_mode_enabled=1
        fi
    done

  if kernel_name="$(uname)"; then
    if [[ "$kernel_name" == "Darwin" ]]; then
      os_category="MacOS"
    elif [[ "$kernel_name" == "Linux" ]]; then
      os_category="Linux"
      default_os_release_filepath="/etc/os-release"
      fallback_os_release_filepath="/usr/lib/os-release"
      # We first try /etc/os-release and then try /usr/lib/os-release as a fallback.
      if test -f "$default_os_release_filepath"; then
        os_release_file="$default_os_release_filepath"
      elif test -f "$fallback_os_release_filepath"; then
        os_release_file="$fallback_os_release_filepath"
      fi
      if test -f "$os_release_file"; then
        linux_distribution="$(cat $os_release_file | sed -nE 's/^NAME="(.*)"$/\1/p')"
      fi
    fi
  fi

    precmd_functions+=(warp_precmd)
    preexec_functions+=(warp_preexec)

    precmd_functions+=(warp_set_title_idle_on_precmd)
    preexec_functions+=(warp_set_title_active_on_preexec)

    if declare -f user_prompt_command 2>&1 >/dev/null; then
        precmd_functions+=(user_prompt_command)
    fi

    WARP_BOOTSTRAPPED=1

    warp_update_prompt_vars

    # Set the history file to append
    shopt -s histappend

    shell_plugins=()

    function warp_bootstrapped () {
        local aliases="`alias`"
        local env_var_names="`compgen -e`"
        local function_names="`compgen -A function`"
        local builtins="`compgen -b`"
        local keywords="`compgen -k`"
        if [ "$WARP_IN_MSYS2" = false ]; then
          # Note that for now we don't support dynamically changing HISTFILE within a session.
          local escaped_histfile="$(warp_escape_json "$HISTFILE")"
          local escaped_abbrs=""
          local escaped_aliases="$(warp_escape_json "$aliases")"
          local escaped_env_var_names="$(warp_escape_json "$env_var_names")"
          local escaped_function_names="$(warp_escape_json "$function_names")"
          local escaped_builtins="$(warp_escape_json "$builtins")"
          local escaped_keywords="$(warp_escape_json "$keywords")"
        fi

        local shell_options="`shopt -s | command -p cut -f 1`"
        # Provide terminal logic access to the value of HISTCONTROL via shell
        # options.  Prefix the fake option with "!" to avoid conflicts with
        # real bash options.
        if [[ -n $USER_HISTCONTROL ]]; then
            shell_options="$shell_options \n !histcontrol_$USER_HISTCONTROL"
        fi

        # Check if Starship is active for Bash. Note that another prompt could still be overriding Starship, however,
        # this is our best guess for the currently active prompt plugin.
        if [ "$STARSHIP_SHELL" = "bash" ]; then
          shell_plugins+=("starship")
        fi

        if [ "$WARP_IN_MSYS2" = false ]; then
          local escaped_shell_plugins=$(warp_escape_json "$shell_plugins")
          local escaped_path="$(warp_escape_json "$PATH")"
          local escaped_shell_options=$(warp_escape_json "$shell_options")
        fi

        local _user=$(command -pv whoami >/dev/null 2>&1 && command -p whoami 2>/dev/null || echo $USER)
        local _hostname=$(command -pv hostname >/dev/null 2>&1 && command -p hostname 2>/dev/null || command -p uname -n)
        if [ "$WARP_IN_MSYS2" = true ]; then
          warp_send_hook_via_kv_pairs_start "Bootstrapped"
          warp_send_hook_kv_pair "histfile" "$HISTFILE"
          warp_send_hook_kv_pair "session_id" "$WARP_SESSION_ID"
          warp_send_hook_kv_pair "shell" "bash"
          warp_send_hook_kv_pair "home_dir" "$HOME"
          warp_send_hook_kv_pair "user" "$_user"
          warp_send_hook_kv_pair "hostname" "$_hostname"
          warp_send_hook_kv_pair "path" "$PATH"
          warp_send_hook_kv_pair "cdpath" "$CDPATH"
          warp_send_hook_kv_pair_escaped "env_var_names" "$env_var_names"
          warp_send_hook_kv_pair "abbreviations" ""
          warp_send_hook_kv_pair_escaped "aliases" "$aliases"
          warp_send_hook_kv_pair_escaped "function_names" "$function_names"
          warp_send_hook_kv_pair_escaped "builtins" "$builtins"
          warp_send_hook_kv_pair_escaped "keywords" "$keywords"
          warp_send_hook_kv_pair "shell_plugins" "$shell_plugins"
          warp_send_hook_kv_pair "shell_version" "$BASH_VERSION"
          warp_send_hook_kv_pair "shell_options" "$shell_options"
          warp_send_hook_kv_pair "rcfiles_start_time" "$rcfiles_start_time"
          warp_send_hook_kv_pair "rcfiles_end_time" "$rcfiles_end_time"
          warp_send_hook_kv_pair "vi_mode_enabled" "$vi_mode_enabled"
          warp_send_hook_kv_pair "os_category" "$os_category"
          warp_send_hook_kv_pair "linux_distribution" "$linux_distribution"
          warp_send_hook_kv_pair "wsl_name" "$WSL_DISTRO_NAME"
          warp_send_hook_kv_pair "shell_path" "$BASH"
          warp_send_hook_via_kv_pairs_end
        else
          local escaped_editor="$(warp_escape_json "$EDITOR")"
          local escaped_shell_path="$(warp_escape_json "$BASH")"
          local escaped_cdpath="$(warp_escape_json "$CDPATH")"
          local escaped_json="{\"hook\": \"Bootstrapped\", \"value\": {\"histfile\": \"$escaped_histfile\", \"session_id\": $WARP_SESSION_ID, \"shell\": \"bash\",  \"home_dir\": \"$HOME\", \"user\":\"$_user\", \"host\":\"$_hostname\", \"path\": \"$escaped_path\", \"cdpath\": \"$escaped_cdpath\", \"editor\": \"$escaped_editor\", \"env_var_names\": \"$escaped_env_var_names\", \"abbreviations\": \"$escaped_abbrs\", \"aliases\": \"$escaped_aliases\", \"function_names\": \"$escaped_function_names\", \"builtins\": \"$escaped_builtins\", \"keywords\": \"$escaped_keywords\", \"shell_version\": \"$BASH_VERSION\", \"shell_options\": \"$escaped_shell_options\", \"rcfiles_start_time\": \"$rcfiles_start_time\", \"rcfiles_end_time\": \"$rcfiles_end_time\", \"vi_mode_enabled\": \"$vi_mode_enabled\", \"os_category\": \"$os_category\", \"linux_distribution\": \"$linux_distribution\", \"wsl_name\": \"$WSL_DISTRO_NAME\", \"shell_path\": \"$escaped_shell_path\"}}"
          warp_send_json_message "$escaped_json"
        fi
    }
    warp_bootstrapped
fi