793 lines
37 KiB
Bash
793 lines
37 KiB
Bash
# Note that WARP_SESSION_ID is expected to have been set when executing commands to
|
|
# emit the InitShell payload, which includes the session ID.
|
|
begin
|
|
# We wrap ourselves in a begin block because these are effectively injected
|
|
# keystrokes, and we want to execute this whole script as a single command.
|
|
# Of course we are fish script, not POSIX shell script.
|
|
# Set fish_private_mode to prevent saving to history.
|
|
# Note: We don't add a leading space to the `begin` command here because this entire script is
|
|
# pasted into fish with bracketed paste, and Fish strips out the leading whitespace. Instead,
|
|
# we insert the space _before_ pasting the script in, which has the same effect
|
|
set -l saved_fish_private_mode $fish_private_mode
|
|
set -g fish_private_mode 1
|
|
|
|
# Disable fish autosuggestions - because input goes through Warp's editor instead,
|
|
# they are never actionable, and the extra output can cause problems.
|
|
set -g fish_autosuggestion_enabled 0
|
|
|
|
# Byte sequence used to signal the start of a DCS. ([0x1b, 0x50, 0x24] which
|
|
# maps to <ESC>, P, $ in ASCII.)
|
|
set -g DCS_START \u1b\u50\u24
|
|
|
|
# Appended to $DCS_START to signal that the following message is JSON-encoded.
|
|
# The Rust app also receives non-JSON-encoded DCS's sent from
|
|
# _warp_run_generator_command_internal, which instead end in 'e' (0x65).
|
|
set -g DCS_JSON_MARKER 'd'
|
|
|
|
set -g DCS_END \x1b\x5c
|
|
|
|
set -g OSC_START (printf '\e]9278;')
|
|
|
|
set -g OSC_END (printf '\a')
|
|
|
|
set -g OSC_PARAM_SEPARATOR ';'
|
|
|
|
set -g RESET_GRID_OSC (printf '\e]9279\a')
|
|
|
|
if test -n "$GALAXY_INITIAL_WORKING_DIR"
|
|
cd "$GALAXY_INITIAL_WORKING_DIR" >/dev/null 2>&1
|
|
set -e GALAXY_INITIAL_WORKING_DIR
|
|
end
|
|
|
|
# Append additional PATH entries if provided via WARP_PATH_APPEND.
|
|
if test -n "$WARP_PATH_APPEND"
|
|
set -gx --path PATH "$PATH:$WARP_PATH_APPEND"
|
|
set -e WARP_PATH_APPEND
|
|
end
|
|
|
|
function warp_send_json_message
|
|
# Sends a message to the controlling terminal as a DSC control sequence.
|
|
set -l escaped_json (warp_hex_encode_string "$argv")
|
|
if [ "$WARP_USING_WINDOWS_CON_PTY" = true ]
|
|
echo -n "$OSC_START$DCS_JSON_MARKER$OSC_PARAM_SEPARATOR$escaped_json$OSC_END"
|
|
else
|
|
echo -n "$DCS_START$DCS_JSON_MARKER$escaped_json$DCS_END"
|
|
end
|
|
end
|
|
|
|
function warp_maybe_send_reset_grid_osc
|
|
# Note that $WARP_USING_WINDOWS_CON_PTY is set in the init shell script.
|
|
if [ "$WARP_USING_WINDOWS_CON_PTY" = true ]
|
|
printf $RESET_GRID_OSC
|
|
end
|
|
end
|
|
|
|
|
|
# warp_hex_encode_string hex-encodes the given string with `od`.
|
|
function warp_hex_encode_string
|
|
echo "$argv" | od -An -v -tx1 | command tr -d ' \n'
|
|
end
|
|
|
|
# A list of PIDs for running in-band command(s). This is used to kill running
|
|
# in-band commands in preexec for a user command, so they do not interfere with
|
|
# user command output.
|
|
set -g _warp_generator_pids ''
|
|
|
|
# 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.
|
|
#
|
|
# Usage:
|
|
# _warp_run_generator_command_internal <command_id> '<command>'
|
|
#
|
|
# The first argument is the command's ID, which is included in the DCS string sent
|
|
# to the rust app. The second argument is the command string itself.
|
|
function _warp_run_generator_command_internal
|
|
set -l command_id $argv[1]
|
|
set -l command (string join -- ' ' (string escape $argv[2]))
|
|
# Fish cannot run shell functions in the background, so in order to run
|
|
# the command in the the background we spawn a fish process, inlining the
|
|
# code necessary to write the command's output OSC to the rust app. This
|
|
# differs from the bash and zsh implementations, which rely on running
|
|
# functions in the background.
|
|
#
|
|
# The `IFS` has to be set to the empty string to prevent fish from converting
|
|
# the command output into a list by splitting output on newlines (fish splits
|
|
# strings on $IFS into lists). Essentially, setting IFS to the empty string
|
|
# allows us to preserve newlines in command output (that might be relied
|
|
# upon) for parsing output.
|
|
#
|
|
# N.B. Fish shell variables cannot contain null characters, so the command output must be
|
|
# immediately hex encoded before being stored in a variable.
|
|
fish -c "
|
|
set -l warp_using_windows_con_pty $WARP_USING_WINDOWS_CON_PTY;
|
|
set -l reset_grid_osc $RESET_GRID_OSC;
|
|
function warp_maybe_send_reset_grid_osc
|
|
if [ \"\$warp_using_windows_con_pty\" = true ]
|
|
printf \$reset_grid_osc
|
|
end
|
|
end
|
|
set -l OSC_START_GENERATOR_OUTPUT \$(printf '\e]9277;A\a')
|
|
set -l OSC_END_GENERATOR_OUTPUT \$(printf '\e]9277;B\a')
|
|
set -l command_id $command_id;
|
|
set -l command $command;
|
|
set -l IFS;
|
|
begin
|
|
echo -n \"\$command_id;\"
|
|
eval \$command 2>&1
|
|
echo -n \";\$status\"
|
|
end | od -An -v -tx1 | command tr -d ' \n' | read -lz hex_encoded_message
|
|
set -l LC_ALL \"C\"
|
|
set -l byte_count (string length \"\$hex_encoded_message\")
|
|
echo -n \"\$OSC_START_GENERATOR_OUTPUT\$byte_count;\$hex_encoded_message\$OSC_END_GENERATOR_OUTPUT\"
|
|
warp_maybe_send_reset_grid_osc" 2> /dev/null &
|
|
|
|
set -l command_pid $last_pid
|
|
set -a _warp_generator_pids $command_pid
|
|
|
|
# Remove the command's PID from _warp_generator_pids when the command exits.
|
|
function on_command_{$command_pid}_finish --on-process-exit $command_pid --inherit-variable command_pid
|
|
set -g _warp_generator_pids (string replace $command_pid '' $_warp_generator_pids)
|
|
|
|
# Erase this function after the pids list is updated above so we don't create an infinite number of
|
|
# functions that could pollute the user's context (nested functions are still existing in the global
|
|
# scope).
|
|
functions -e on_command_{$command_pid}_finish
|
|
|
|
# Note: If we're on windows, we send a reset grid to erase any cursor mutations caused by
|
|
# the in-band command.
|
|
warp_maybe_send_reset_grid_osc
|
|
end
|
|
end
|
|
|
|
# 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>'
|
|
function warp_run_generator_command
|
|
# Setting this environment variable allows warp_precmd to detect if a generator
|
|
# command or a user command has just completed.
|
|
set -g _WARP_GENERATOR_COMMAND 1
|
|
_warp_run_generator_command_internal $argv
|
|
end
|
|
|
|
# Run before a command is executed.
|
|
function warp_preexec --on-event fish_preexec
|
|
set -l command (warp_escape_json "$argv")
|
|
warp_send_json_message "{\"hook\": \"Preexec\", \"value\": {\"command\": \"$command\", \"session_id\": $WARP_SESSION_ID}}"
|
|
warp_maybe_send_reset_grid_osc
|
|
|
|
# If this preexec is called for user command, kill ongoing generator command jobs.
|
|
if test (! string match -q "warp_run_generator_command*" $argv[1])
|
|
for pid in $_warp_generator_pids
|
|
# 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
|
|
end
|
|
set -g _warp_generator_pids ''
|
|
end
|
|
end
|
|
|
|
# The git prompts 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.
|
|
function warp_git
|
|
GIT_OPTIONAL_LOCKS=0 command git $argv
|
|
end
|
|
|
|
# Wrap fish prompt function output with OSC prompt marker sequences,
|
|
# so that we can direct the prompt bytes to the appropriate grids.
|
|
function warp_update_prompt_vars
|
|
# Back up the original fish_prompt if not already done
|
|
if not functions -q warp_original_fish_prompt
|
|
functions -c fish_prompt warp_original_fish_prompt
|
|
end
|
|
|
|
# Back up the original fish_right_prompt if it exists and not already backed up
|
|
if functions -q fish_right_prompt; and not functions -q warp_original_fish_right_prompt
|
|
functions -c fish_right_prompt warp_original_fish_right_prompt
|
|
end
|
|
|
|
# If not honoring PS1, set both prompts to be empty
|
|
if test "$WARP_HONOR_PS1" = "0"
|
|
function fish_prompt; echo -n ""; end
|
|
function fish_right_prompt; echo -n ""; end
|
|
# If honoring PS1, add prefix/suffix to both prompts
|
|
else
|
|
|
|
function end_prompt
|
|
echo -n (printf '\x1b')
|
|
if test "$WARP_HONOR_PS1" != "1" && [ "$WARP_USING_WINDOWS_CON_PTY" = true ]
|
|
echo -n "]133;B$RESET_GRID_OSC"
|
|
else
|
|
echo -n ']133;B'
|
|
end
|
|
echo -n (printf '\x07')
|
|
end
|
|
|
|
# Redefine fish_prompt to include prefix and suffix
|
|
function fish_prompt
|
|
echo -n (printf '\x1b')
|
|
echo -n ']133;A'
|
|
echo -n (printf '\x07')
|
|
warp_original_fish_prompt
|
|
end_prompt
|
|
end
|
|
|
|
# Check if warp_original_fish_right_prompt was backed up before redefining fish_right_prompt
|
|
if functions -q warp_original_fish_right_prompt
|
|
function fish_right_prompt
|
|
echo -n (printf '\x1b')
|
|
echo -n ']133;P;k=r'
|
|
echo -n (printf '\x07')
|
|
warp_original_fish_right_prompt
|
|
end_prompt
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
# Changes the WARP_HONOR_PS1 variable to 1, to indicate we want to use the user's custom prompt. Restores
|
|
# the original fish prompt functions (which we set to empty for Warp prompt) by calling warp_update_prompt_vars
|
|
# to refresh the prompt. We force a repaint of the prompt to ensure the change is reflected immediately.
|
|
function warp_change_prompt_modes_to_ps1
|
|
set -x WARP_HONOR_PS1 "1"
|
|
|
|
# Restores fish_prompt and fish_right_prompt.
|
|
warp_update_prompt_vars
|
|
# Forces a repaint of the current prompt to ensure the change is reflected immediately.
|
|
commandline -f repaint
|
|
end
|
|
|
|
# Changes the WARP_HONOR_PS1 variable to 0, to indicate we want to use the Warp prompt. Saves and clears
|
|
# the fish prompt functions (which we set to empty for Warp prompt) by calling warp_update_prompt_vars
|
|
# to refresh the prompt. We force a repaint of the prompt to ensure the change is reflected immediately.
|
|
function warp_change_prompt_modes_to_warp_prompt
|
|
set -x WARP_HONOR_PS1 "0"
|
|
|
|
# Updates fish_prompt and fish_right_prompt to be empty.
|
|
warp_update_prompt_vars
|
|
# Forces a repaint of the current prompt to ensure the change is reflected immediately.
|
|
commandline -f repaint
|
|
end
|
|
|
|
set block_id 0
|
|
# Run before the prompt is displayed. We also need to trigger this on "fish_posterror", as
|
|
# submitting a command containing a syntax error will not trigger "fish_preexec" or "fish_prompt".
|
|
function warp_precmd --on-event fish_prompt --on-event fish_posterror
|
|
# Handle prompt behavior (we do this first to make sure the exit status is from the command,
|
|
# rather than from our own code)
|
|
set -l exit_code $status
|
|
|
|
# This function is triggered by both "fish_prompt" and "fish_posterror" events. If it was
|
|
# "fish_prompt", then $status will be properly set. If it was "fish_posterror", it won't be.
|
|
# We want to set the exit code to 1 for errors, but there is no direct way to check which event
|
|
# triggered this function call. The length of $argv actually tells us, as "fish_posterror"
|
|
# passes the erroneous command while "fish_prompt" passes nothing.
|
|
if test (count $argv) -gt 0
|
|
set exit_code 1
|
|
end
|
|
|
|
set -l next_block_id "precmd-$WARP_SESSION_ID-$block_id"
|
|
warp_send_json_message "{\"hook\": \"CommandFinished\", \"value\": {\"exit_code\": $exit_code, \"next_block_id\": \"$next_block_id\", \"session_id\": $WARP_SESSION_ID}}"
|
|
warp_maybe_send_reset_grid_osc
|
|
|
|
set block_id (math $block_id + 1)
|
|
|
|
if ! test -z $_WARP_GENERATOR_COMMAND
|
|
set -e _WARP_GENERATOR_COMMAND
|
|
set -l escaped_json "{\"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
|
|
}}"
|
|
warp_send_json_message $escaped_json
|
|
return 0
|
|
end
|
|
|
|
# Fish's vi mode causes a conflict with the input reporting binding.
|
|
# Set the bindings back for this session. Note that just calling fish_default_key_bindings
|
|
# affects other sessions so we do it this way instead.
|
|
set -g fish_key_bindings fish_default_key_bindings
|
|
|
|
# Do not use kill-line because of the kill ring interation.
|
|
bind \cP "commandline ''"
|
|
|
|
# We use the ESC-p bindkey for this ("p" for PS1/custom prompt).
|
|
bind \ep warp_change_prompt_modes_to_ps1
|
|
|
|
# We use the ESC-w bindkey for this ("w" for Warp prompt).
|
|
bind \ew warp_change_prompt_modes_to_warp_prompt
|
|
|
|
bind \ei warp_report_input
|
|
|
|
# Define local variables in appropriate outer block for fish variable scoping.
|
|
# See https://stackoverflow.com/a/53685510.
|
|
set -l escaped_prompt
|
|
set -l escaped_right_prompt
|
|
|
|
set -l escaped_pwd
|
|
if set -q WSL_DISTRO_NAME
|
|
# In WSL, avoid symlinks b/c on Windows `std::fs` is unable to resolve symlink inside WSL containers.
|
|
set escaped_pwd (warp_escape_json (pwd -P))
|
|
else
|
|
set escaped_pwd (warp_escape_json $PWD)
|
|
end
|
|
|
|
set -l escaped_virtual_env ""
|
|
set -l escaped_conda_env ""
|
|
set -l escaped_node_version ""
|
|
set -l escaped_git_head ""
|
|
set -l escaped_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 test -n "$WARP_BOOTSTRAPPED"
|
|
if test -n "$VIRTUAL_ENV"
|
|
set escaped_virtual_env (warp_escape_json "$VIRTUAL_ENV")
|
|
end
|
|
if test -n "$CONDA_DEFAULT_ENV"
|
|
set escaped_conda_env (warp_escape_json "$CONDA_DEFAULT_ENV")
|
|
end
|
|
|
|
# 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 test "$WARP_PROMPT_NODE_VERSION_ENABLED" != "0"; and command -v node > /dev/null 2>&1
|
|
# Check for package.json in current directory and parent directories
|
|
set current_dir (pwd)
|
|
set found_package_json false
|
|
set package_json_dir ""
|
|
while test -n "$current_dir"
|
|
if test -f "$current_dir/package.json"
|
|
set found_package_json true
|
|
set package_json_dir "$current_dir"
|
|
break
|
|
end
|
|
if test "$current_dir" = "/"
|
|
break
|
|
end
|
|
# Strip the last path segment without spawning `dirname`.
|
|
set current_dir (string replace -r '/[^/]*$' '' -- "$current_dir")
|
|
if test -z "$current_dir"
|
|
set current_dir "/"
|
|
end
|
|
end
|
|
|
|
# Only show node version if package.json is within a git repository
|
|
if test "$found_package_json" = true
|
|
set git_dir "$package_json_dir"
|
|
set in_git_repo false
|
|
while test -n "$git_dir"
|
|
if test -d "$git_dir/.git"
|
|
set in_git_repo true
|
|
break
|
|
end
|
|
if test "$git_dir" = "/"
|
|
break
|
|
end
|
|
set git_dir (string replace -r '/[^/]*$' '' -- "$git_dir")
|
|
if test -z "$git_dir"
|
|
set git_dir "/"
|
|
end
|
|
end
|
|
|
|
if test "$in_git_repo" = true
|
|
# 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`). Use global cache vars so they persist across calls.
|
|
set -l node_cache_key "$PWD:$PATH"
|
|
if test "$node_cache_key" = "$_WARP_NODE_VERSION_CACHE_KEY"
|
|
set escaped_node_version "$_WARP_NODE_VERSION_CACHE_VALUE"
|
|
else
|
|
set -l node_version (node --version 2>/dev/null)
|
|
if test -n "$node_version"
|
|
set escaped_node_version (warp_escape_json "$node_version")
|
|
end
|
|
set -g _WARP_NODE_VERSION_CACHE_KEY "$node_cache_key"
|
|
set -g _WARP_NODE_VERSION_CACHE_VALUE "$escaped_node_version"
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
set -l git_branch ""
|
|
set -l git_head ""
|
|
if command -q git
|
|
set git_branch (warp_git symbolic-ref --short HEAD 2> /dev/null)
|
|
if test -z "$git_branch"
|
|
# Fallback to the git commit hash if we aren't on a named branch.
|
|
set git_head (warp_git rev-parse --short HEAD 2> /dev/null)
|
|
else
|
|
set git_head "$git_branch"
|
|
end
|
|
end
|
|
set escaped_git_head (warp_escape_json "$git_head")
|
|
set escaped_git_branch (warp_escape_json "$git_branch")
|
|
end
|
|
|
|
warp_update_prompt_vars
|
|
# This is used solely for prompt previews, when we're using prompt markers with combined grid.
|
|
# We need to use this since fish does not have a way to ignore printable characters for cursor
|
|
# positioning (unlike zsh/bash), so we need a separate mechanism to send the prompt to Warp
|
|
# in the case of Warp prompt (for previewing the PS1). We send an escaped version of the raw prompt
|
|
# bytes via a hex string (in a JSON payload) to Warp.
|
|
# Note that we are CALLING the `warp_original_fish_prompt` function on the next line and assigning the
|
|
# outputted string to the local variable `raw_prompt_for_preview`.
|
|
set -l raw_prompt_for_preview (warp_original_fish_prompt)
|
|
# We encode the prompt as a hex string to pass it to Warp.
|
|
set escaped_prompt (warp_escape_prompt "$raw_prompt_for_preview")
|
|
|
|
set -l escaped_json
|
|
if test "$WARP_HONOR_PS1" = "1"
|
|
# Don't send lprompt or rprompt in this case - we'll use prompt markers for both directly!
|
|
set escaped_json "{\"hook\": \"Precmd\", \"value\": {
|
|
\"exit_code\": $exit_code,
|
|
\"next_block_id\": \"$next_block_id\",
|
|
\"pwd\": \"$escaped_pwd\",
|
|
\"ps1\": \"\",
|
|
\"rprompt\": \"\",
|
|
\"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
|
|
}}"
|
|
else
|
|
# We send an lprompt to use for prompt preview purposes only (we still use prompt markers for active prompts).
|
|
set escaped_json "{\"hook\": \"Precmd\", \"value\": {
|
|
\"exit_code\": $exit_code,
|
|
\"next_block_id\": \"$next_block_id\",
|
|
\"pwd\": \"$escaped_pwd\",
|
|
\"ps1\": \"$escaped_prompt\",
|
|
\"rprompt\": \"\",
|
|
\"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
|
|
}}"
|
|
end
|
|
warp_send_json_message $escaped_json
|
|
end
|
|
|
|
function warp_escape_prompt
|
|
# To match the implementation of PS1 support in bash / zsh, we use the same method of encoding
|
|
# the prompt as a hex string so that it can be interpreted on the Warp side
|
|
# Note: before converting the prompt to a hex string, we remove any multi-line newlines and
|
|
# replace them with a single space (to avoid prompts that span multiple empty lines)
|
|
echo "$argv" | command tr '\n\n' ' ' | command od -An -v -tx1 | command tr -d ' \n'
|
|
end
|
|
|
|
# Escapes string(s) passed as input to be JSON-serializable.
|
|
#
|
|
# Specifically, special characters like backspace, tab, form feed, carriage return, and newlines
|
|
# are replaced with escaped equivalents. Double quotes and literal backslash characters are also
|
|
# backslash-escaped.
|
|
function 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/ - Replace any newlines (except the last trailing newline) with the literal \n character
|
|
#
|
|
# Additional note: In Fish, backslashes still need to be escaped in single quoted strings. So each `\\` below
|
|
# represents a single `\` in the above regex explanation. We also close the single-quoted string in order to
|
|
# insert literal characters (Fish supports literals with escapes when not quoting)
|
|
#
|
|
# We also use 'command sed' to ensure that we aren't accidentally executing a function named 'sed'
|
|
string join \n $argv | command sed -E 's/(["\\\\])/\\\\\\1/g; s/'\b'/\\\\b/g; s/'\t'/\\\\t/g; s/'\f'/\\\\f/g; s/'\r'/\\\\r/g; $!s/$/\\\\n/' | command tr -d '\n'
|
|
end
|
|
|
|
function warp_bootstrapped
|
|
set -l histfile_directory
|
|
set histfile_directory "$XDG_DATA_HOME"
|
|
if test -z "$histfile_directory"
|
|
set histfile_directory "$HOME/.local/share"
|
|
end
|
|
set -l escaped_histfile (warp_escape_json "$histfile_directory/fish/fish_history")
|
|
|
|
set -l vi_mode_enabled ""
|
|
if [ "$fish_key_bindings" = "fish_vi_key_bindings" ]
|
|
set vi_mode_enabled "1"
|
|
end
|
|
|
|
set -l kernel_name (uname)
|
|
if test -n "$kernel_name"
|
|
if [ "$kernel_name" = "Darwin" ]
|
|
set os_category "MacOS"
|
|
else if [ "$kernel_name" = "Linux" ]
|
|
set os_category "Linux"
|
|
set -l default_os_release_filepath "/etc/os-release"
|
|
set -l 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"
|
|
set os_release_file "$default_os_release_filepath";
|
|
else if test -f "$fallback_os_release_filepath"
|
|
set os_release_file "$fallback_os_release_filepath";
|
|
end
|
|
if test -f "$os_release_file"
|
|
set linux_distribution (cat $os_release_file | sed -nE 's/^NAME="(.*)"$/\1/p')
|
|
end
|
|
end
|
|
end
|
|
|
|
set -l escaped_abbr (warp_escape_json (abbr --show))
|
|
set -l escaped_aliases (warp_escape_json (alias))
|
|
set -l env_var_names (warp_escape_json (set --names))
|
|
set -l function_names (warp_escape_json (functions -an))
|
|
set -l escaped_builtins (warp_escape_json (builtin -n))
|
|
# Note "keywords" is set to an empty string since fish includes keywords as a
|
|
# part of its builtins (e.g. "for", "while", etc.).
|
|
set -l escaped_editor (warp_escape_json "$EDITOR")
|
|
set -l escaped_shell_path (warp_escape_json (status fish-path))
|
|
set -l escaped_json "{\"hook\": \"Bootstrapped\", \"value\": {\"histfile\": \"$escaped_histfile\", \"session_id\": $WARP_SESSION_ID, \"shell\": \"fish\", \"home_dir\": \"$HOME\", \"path\": \"$PATH\", \"editor\": \"$escaped_editor\", \"abbreviations\": \"$escaped_abbr\", \"aliases\": \"$escaped_aliases\", \"function_names\": \"$function_names\", \"env_var_names\": \"$env_var_names\", \"builtins\": \"$escaped_builtins\", \"keywords\": \"\", \"shell_version\": \"$FISH_VERSION\", \"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
|
|
end
|
|
|
|
function warp_init_shell
|
|
set -l init_shell "{\"hook\": \"InitShell\", \"value\": {\"shell\": \"$argv\"}}"
|
|
warp_hex_encode_string "$init_shell"
|
|
end
|
|
|
|
# Add a key binding to report the current input buffer to Warp. We can override
|
|
# any user-defined binds here because user input goes through Warp's editor, not
|
|
# the fish line editor.
|
|
# This is arbitrarily bound to ESC-i in all supported shells ("i" for input).
|
|
# Binding to ESC-1 caused bootstrap failures with vi keybindings.
|
|
function warp_report_input
|
|
set -l escaped_input (warp_escape_json (commandline))
|
|
warp_send_json_message "{ \"hook\": \"InputBuffer\", \"value\": { \"buffer\": \"$escaped_input\", \"session_id\": $WARP_SESSION_ID } }"
|
|
# This prevents fish from rendering typeahead as background output once we've collected it.
|
|
commandline ''
|
|
end
|
|
|
|
function clear
|
|
warp_send_json_message "{\"hook\": \"Clear\", \"value\": {\"session_id\": $WARP_SESSION_ID}}"
|
|
end
|
|
|
|
function warp_finish_update
|
|
set -l update_id "$argv[1]"
|
|
warp_send_json_message "{\"hook\": \"FinishUpdate\", \"value\": { \"update_id\": \"$update_id\", \"session_id\": $WARP_SESSION_ID}}"
|
|
end
|
|
|
|
|
|
# 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
|
|
set -l source_file_name "$argv[1]"
|
|
|
|
# The `apt-config shell` command outputs an environment variable assignment in POSIX-compliant syntax. Therefore,
|
|
# we need to run this from within an sh shell to actually get the correct directory for the sources dir.
|
|
set -l APT_SOURCESDIR (command sh -c 'eval $(apt-config shell APT_SOURCESDIR "Dir::Etc::sourceparts/d"); echo $APT_SOURCESDIR')
|
|
|
|
if not test -e $APT_SOURCESDIR$source_file_name.list; and not test -e $APT_SOURCESDIR$source_file_name.sources; and test -e $APT_SOURCESDIR$source_file_name.list.distUpgrade
|
|
# 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"
|
|
end
|
|
end
|
|
|
|
# The SSH logic only applies to local sessions, because we don't yet have support for bootstrapping
|
|
# recursive SSH sessions.
|
|
if test "$WARP_IS_LOCAL_SHELL_SESSION" = "1"
|
|
function is_interactive_ssh_session
|
|
# Parse through all ssh options, as defined in the ssh man pages. Send
|
|
# stderr to /dev/null to silence argparse output when an option is invalid.
|
|
argparse '1' '2' '4' '6' 'A' 'a' 'C' 'f' 'g' 'K' 'k' 'M' 'N' 'n' 'q' 's' 'T' 't' 'V' 'v' 'X' 'x' 'Y' 'y' 'b=' 'c=' 'D=' 'e=' 'F=' 'i=' 'L=' 'l=' 'm=' 'O=' 'o=' 'p=' 'R=' 'S=' 'W=' 'w=' -- $argv 2>/dev/null
|
|
# If argparse returned a non-success value, propagate it up.
|
|
or return
|
|
|
|
if [ $_flag_T ]
|
|
# -T disables pty allocation (aka a non-interactive session)
|
|
return 1
|
|
end
|
|
if [ $_flag_W ]
|
|
# -W implies -T
|
|
return 1
|
|
end
|
|
|
|
# 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 [ (count $argv) -ne 1 ]
|
|
return 1
|
|
end
|
|
end
|
|
|
|
function warp_ssh_helper
|
|
set -l init_shell_zsh (warp_init_shell "zsh")
|
|
set -l init_shell_bash (warp_init_shell "bash")
|
|
set -l remote_session_id (command od -An -N8 -tu8 /dev/urandom 2>/dev/null | command tr -d ' \n')
|
|
if test -z "$remote_session_id"; or test "$remote_session_id" = "0"
|
|
# If we cannot generate a non-zero random token, run plain SSH instead.
|
|
command ssh $argv
|
|
return
|
|
end
|
|
# 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
|
|
set -l 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 || 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 '"'"'\x1b\x50\x24\x64%s\x1b\x5c'"'"' $_msg; unset _hostname _user _msg' | command od -An -v -tx1 | command 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.
|
|
set -l control_path "$SSH_SOCKET_DIR/$WARP_SESSION_ID"
|
|
set -l control_master_mode "yes"
|
|
set -l external_control_master "false"
|
|
if test "$WARP_SSH_REUSE_CONTROL_MASTER" = "1"
|
|
set -l user_control_path (command ssh -G $argv 2>/dev/null | command sed -n 's/^controlpath //p')
|
|
# Skip when no ControlPath is configured, and reject resolved
|
|
# paths containing characters we cannot safely embed in the SSH
|
|
# hook JSON below (e.g. an unexpanded % token, quotes, or
|
|
# whitespace); in those cases fall back to a Warp-owned master.
|
|
if test -n "$user_control_path"
|
|
and test "$user_control_path" != "none"
|
|
and string match --quiet --regex '^[A-Za-z0-9._/~@:+,-]+$' -- "$user_control_path"
|
|
if command ssh -O check -o ControlPath="$user_control_path" $argv >/dev/null 2>&1
|
|
# A live master exists: multiplex through it and let the
|
|
# client know Warp does not own it.
|
|
set control_path "$user_control_path"
|
|
set control_master_mode "no"
|
|
set external_control_master "true"
|
|
end
|
|
end
|
|
end
|
|
|
|
# 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 $argv \
|
|
"
|
|
export TERM_PROGRAM='WarpTerminal'
|
|
test -n '$WARP_CLIENT_VERSION' && export WARP_CLIENT_VERSION='$WARP_CLIENT_VERSION'
|
|
# Only forward the protocol version if it was set locally (i.e. the HOANotifications feature flag is on).
|
|
test -n '$WARP_CLI_AGENT_PROTOCOL_VERSION' && export WARP_CLI_AGENT_PROTOCOL_VERSION='$WARP_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 od -An -v -tx1 | command tr -d " \n")'"
|
|
printf '$DCS_START$DCS_JSON_MARKER%s$DCS_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
|
|
cat /etc/motd
|
|
elif test -r /run/motd; then
|
|
cat /run/motd
|
|
elif test -r /run/motd.dynamic; then
|
|
cat /run/motd.dynamic
|
|
elif test -r /usr/lib/motd; then
|
|
cat /usr/lib/motd
|
|
elif test -r /usr/lib/motd.dynamic; then
|
|
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 '"'
|
|
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 || 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\": \"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 '\''"'\x1b\x50\x24\x64%s\x1b\x5c'"'\'' \""'$_msg'"\"'
|
|
unset _hostname _user _msg
|
|
)
|
|
;;
|
|
zsh) WARP_TMP_DIR="'$(mktemp -d warptmp.XXXXXX)'"
|
|
local ZSH_ENV_SCRIPT='$zsh_env_script'
|
|
if [[ "'$?'" == 0 ]]; then
|
|
if command -v xxd >/dev/null 2>&1; then
|
|
echo "'$ZSH_ENV_SCRIPT'" | command 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
|
|
"
|
|
end
|
|
|
|
function ssh
|
|
if is_interactive_ssh_session $argv
|
|
warp_send_json_message "{\"hook\": \"PreInteractiveSSHSession\", \"value\": {\"session_id\": $WARP_SESSION_ID}}"
|
|
|
|
if [ "$WARP_USE_SSH_WRAPPER" = "1" ]
|
|
if test $WARP_SHELL_DEBUG_MODE
|
|
set -g TRACE_FLAG_IF_WARP_SHELL_DEBUG_MODE "-x"
|
|
else
|
|
set -g TRACE_FLAG_IF_WARP_SHELL_DEBUG_MODE ""
|
|
end
|
|
warp_ssh_helper $argv
|
|
else
|
|
command ssh $argv
|
|
end
|
|
else
|
|
command ssh $argv
|
|
end
|
|
end
|
|
end
|
|
|
|
warp_precmd
|
|
|
|
# Print the MotD if this is a login shell. Normally, login(1) or pam_motd(8)
|
|
# would do this. However, Warp does not use login(1) for local sessions and for
|
|
# remote sessions, SSHD thinks it is starting a non-interactive session, so it
|
|
# does not print PAM messages.
|
|
if status --is-login
|
|
and test ! -e "$HOME/.hushlogin"
|
|
for motd_file in /etc/motd /run/motd /run/motd.dynamic /usr/lib/motd /usr/lib/motd.dynamic;
|
|
if test -r "$motd_file"
|
|
command cat "$motd_file"
|
|
break
|
|
end
|
|
end
|
|
end
|
|
|
|
warp_bootstrapped
|
|
|
|
set -g WARP_BOOTSTRAPPED 1
|
|
set -g fish_private_mode $saved_fish_private_mode
|
|
end
|